def __init__(self, parent=None):
QObject.__init__(self, parent)
self.__scheme = None
self.__signal_manager = None
self.__widgets = []
self.__initstate_for_node = {}
self.__creation_policy = WidgetManager.Normal
#: a queue of all nodes whose widgets are scheduled for
#: creation/initialization
self.__init_queue = deque() # type: Deque[SchemeNode]
#: Timer for scheduling widget initialization
self.__init_timer = QTimer(self, interval=0, singleShot=True)
self.__init_timer.timeout.connect(self.__create_delayed)
#: A mapping of SchemeNode -> OWWidget (note: a mapping is only added
#: after the widget is actually created)
self.__widget_for_node = {}
#: a mapping of OWWidget -> SchemeNode
self.__node_for_widget = {}
# Widgets that were 'removed' from the scheme but were at
# the time in an input update loop and could not be deleted
# immediately
self.__delay_delete = set()
#: Deleted/removed during creation/initialization.
self.__delete_after_create = []
#: processing state flags for all widgets (including the ones
#: in __delay_delete).
#: Note: widgets which have not yet been created do not have an entry
self.__widget_processing_state = {}
# Tracks the widget in the update loop by the SignalManager
self.__updating_widget = None
def __init__(self, parent=None, minimum=0, maximum=0, text="", value=0):
QObject.__init__(self, parent)
self._minimum = minimum
self._maximum = max(maximum, minimum)
self._text = text
self._value = value
def __init__(self, parent=None):
QObject.__init__(self, parent)
self.__scheme = None
self.__signal_manager = None
self.__widgets = []
self.__initstate_for_node = {}
self.__creation_policy = WidgetManager.Normal
#: a queue of all nodes whose widgets are scheduled for
#: creation/initialization
self.__init_queue = deque() # type: Deque[SchemeNode]
#: Timer for scheduling widget initialization
self.__init_timer = QTimer(self, interval=0, singleShot=True)
self.__init_timer.timeout.connect(self.__create_delayed)
#: A mapping of SchemeNode -> OWWidget (note: a mapping is only added
#: after the widget is actually created)
self.__widget_for_node = {}
#: a mapping of OWWidget -> SchemeNode
self.__node_for_widget = {}
# Widgets that were 'removed' from the scheme but were at
# the time in an input update loop and could not be deleted
# immediately
self.__delay_delete = set()
#: Deleted/removed during creation/initialization.
self.__delete_after_create = []
#: processing state flags for all widgets (including the ones
#: in __delay_delete).
#: Note: widgets which have not yet been created do not have an entry
self.__widget_processing_state = {}
# Tracks the widget in the update loop by the SignalManager
self.__updating_widget = None
def __init__(self, obj, propertyName, parent=None):
QObject.__init__(self, parent)
self.obj = obj
self.propertyName = propertyName
self.obj.destroyed.connect(self._on_destroyed)
self._source = None
def __init__(self):
QObject.__init__(self)
self._name = ''
self._scope = []
self._settings = {}
self._daq = None
self._sigin = 0
self._sigout = 0
self._scope_time = 1
self._tc = 0
self._freq = 0
self._rate = 0
try:
port, apilevel = self._discover()
self.server = ziPython.ziDAQServer('localhost', port, apilevel)
self.server.connect()
msg = self._load_settings()
self.server.set(self._settings['server'])
self.server.sync()
self._get_config()
self._daq = self.server.dataAcquisitionModule()
self.last_action = 'Lockin found, %s' % (msg)
except Exception as e:
self.last_action = str(e)
def test_expr(self):
obj1 = QObject()
obj1.setProperty("value", 1)
obj1.setProperty("other", 2)
result = DynamicPropertyBinding(obj1, "result")
result.bindTo(
PropertyBindingExpr(
"value + other",
locals={"value": binding_for(obj1, "value"),
"other": binding_for(obj1, "other")}
)
)
expr = PropertyBindingExpr(
"True if value < 3 else False",
dict(value=DynamicPropertyBinding(obj1, "result"))
)
result_values = []
result.changed[object].connect(result_values.append)
expr_values = []
expr.changed[object].connect(expr_values.append)
self.assertEqual(result.get(), 3)
self.assertEqual(expr.get(), False)
obj1.setProperty("value", 0)
self.assertEqual(result_values[-1], 2)
self.assertEqual(expr_values[-1], True)
self.assertEqual(result.get(), 2)
self.assertEqual(expr.get(), True)
def __init__(self, widget, parent=None):
QObject.__init__(self)
gui.OWComponent.__init__(self, widget)
self.view_box = MapViewBox(self)
self.plot_widget = pg.PlotWidget(viewBox=self.view_box,
parent=parent,
background="w")
self.plot_widget.hideAxis("left")
self.plot_widget.hideAxis("bottom")
self.plot_widget.getPlotItem().buttonsHidden = True
self.plot_widget.setAntialiasing(True)
self.plot_widget.sizeHint = lambda: QSize(500, 500)
self.master = widget # type: OWChoropleth
self._create_drag_tooltip(self.plot_widget.scene())
self.choropleth_items = [] # type: List[ChoroplethItem]
self.n_ids = 0
self.selection = None # np.ndarray
self.palette = None
self.color_legend = self._create_legend(((1, 1), (1, 1)))
self.update_legend_visibility()
self._tooltip_delegate = HelpEventDelegate(self.help_event)
self.plot_widget.scene().installEventFilter(self._tooltip_delegate)
def __init__(self, obj, propertyName, parent=None):
QObject.__init__(self, parent)
self.obj = obj
self.propertyName = propertyName
self.obj.destroyed.connect(self._on_destroyed)
self._source = None
def __init__(self, source_node, source_channel,
sink_node, sink_channel, enabled=True, properties=None,
parent=None):
QObject.__init__(self, parent)
self.source_node = source_node
if isinstance(source_channel, str):
source_channel = source_node.output_channel(source_channel)
elif source_channel not in source_node.output_channels():
raise ValueError("%r not in in nodes output channels." \
% source_channel)
self.source_channel = source_channel
self.sink_node = sink_node
if isinstance(sink_channel, str):
sink_channel = sink_node.input_channel(sink_channel)
elif sink_channel not in sink_node.input_channels():
raise ValueError("%r not in in nodes input channels." \
% source_channel)
self.sink_channel = sink_channel
if not compatible_channels(source_channel, sink_channel):
raise IncompatibleChannelTypeError(
"Cannot connect %r to %r"
% (source_channel.type, sink_channel.type)
)
self.__enabled = enabled
self.__dynamic_enabled = False
self.__state = SchemeLink.NoState
self.__tool_tip = ""
self.properties = properties or {}
def __init__(self, parent_widget, parent_component):
QObject.__init__(self)
OWComponent.__init__(self, widget=parent_widget)
box = gui.widgetBox(parent_component, orientation=Qt.Horizontal)
self.page_limit = gui.radioButtons(
box,
self,
'items_per_page',
[str(val) for val in ItemsPerPage.values()],
orientation=Qt.Horizontal,
callback=self.on_limit_changed,
label=self.PAGE_LIMIT_LABEL,
)
self.page_left_btn = QToolButton()
self.page_left_btn.setStyleSheet('QToolButton {border: none;}')
self.page_left_btn.setArrowType(Qt.LeftArrow)
self.page_left_btn.pressed.connect(self.left_btn_pressed)
self.offset_label = gui.label(None, self, str(self.current_page), labelWidth=15)
self.offset_label.setAlignment(Qt.AlignCenter)
self.page_right_btn = QToolButton()
self.page_right_btn.setStyleSheet('QToolButton {border: none;}')
self.page_right_btn.setArrowType(Qt.RightArrow)
self.page_right_btn.pressed.connect(self.right_btn_pressed)
parent_widget.pagination_availability.connect(self._handle_paginate_buttons)
box.layout().addStretch(1)
box.layout().addWidget(self.page_left_btn)
box.layout().addWidget(self.offset_label)
box.layout().addWidget(self.page_right_btn)
def __init__(self, parent=None, minimum=0, maximum=0, text="", value=0):
QObject.__init__(self, parent)
self._minimum = minimum
self._maximum = max(maximum, minimum)
self._text = text
self._value = value
def __init__(self, parent_widget, parent_component):
QObject.__init__(self)
OWComponent.__init__(self, widget=parent_widget)
box = gui.widgetBox(parent_component, self.BOX_TITLE, margin=3)
gui.checkBox(box,
self,
'quantile_norm',
self.QUANTILE_NORM_LABEL,
callback=self.options_changed.emit)
gui.checkBox(box,
self,
'log_norm',
self.LOG_NORM_LABEL,
callback=self.options_changed.emit)
gui.checkBox(box,
self,
'z_score_norm',
self.Z_SCORE_LABEL,
callback=self.on_z_score_selected)
self.z_score_axis_btn = gui.radioButtons(
gui.indentedBox(box),
self,
'z_score_axis',
btnLabels=['columns', 'rows'],
callback=self.options_changed.emit,
orientation=Qt.Horizontal,
)
self.z_score_axis_btn.setHidden(not bool(self.z_score_norm))
gui.checkBox(
box,
self,
'quantile_transform',
self.QUANTILE_TRANSFORM_LABEL,
callback=self.on_quantile_transform_selected,
)
self.quantile_transform_axis_btn = gui.radioButtons(
gui.indentedBox(box),
self,
'quantile_transform_axis',
btnLabels=['columns', 'rows'],
callback=self.options_changed.emit,
orientation=Qt.Horizontal,
)
self.quantile_transform_dist_btn = gui.radioButtons(
gui.indentedBox(box),
self,
'quantile_transform_dist',
btnLabels=QuantileTransformDist.values(),
callback=self.options_changed.emit,
orientation=Qt.Horizontal,
)
self.quantile_transform_axis_btn.setHidden(
not bool(self.quantile_transform))
self.quantile_transform_dist_btn.setHidden(
not bool(self.quantile_transform))
def __init__(self, qpart):
QObject.__init__(self, qpart)
self._request_info = {}
self.ready = False
self._qpart = qpart
self._widget = CompletionWidget(self._qpart, self._qpart.parent())
self._opened_automatically = True
self._complete()
def __init__(self, parent=None, threadPool=None):
QObject.__init__(self, parent)
if threadPool is None:
threadPool = QThreadPool.globalInstance()
self._threadPool = threadPool
self._depot_thread = None
self._futures = []
self._shutdown = False
self._state_lock = threading.Lock()
def __init__(self, parent=None, threadPool=None):
QObject.__init__(self, parent)
if threadPool is None:
threadPool = QThreadPool.globalInstance()
self._threadPool = threadPool
self._depot_thread = None
self._futures = []
self._shutdown = False
self._state_lock = threading.Lock()
def __init__(self, parent=None, defaults=(), path=None, store=None):
QObject.__init__(self, parent)
if store is None:
store = QSettings()
path = path = (path or "").rstrip("/")
self.__path = path
self.__defaults = dict([(slot.key, slot) for slot in defaults])
self.__store = store
def __init__(self, parent=None, defaults=(), path=None, store=None):
QObject.__init__(self, parent)
if store is None:
store = QSettings()
path = path = (path or "").rstrip("/")
self.__path = path
self.__defaults = dict([(slot.key, slot) for slot in defaults])
self.__store = store
def __init__(self, parent=None):
QObject.__init__(self, parent)
self.__splitter = None
self.__widget = None
self.__updateOnShow = True # Need __update on next show event
self.__animationEnabled = True
self.__size = -1
self.__expanded = False
self.__animation = QPropertyAnimation(self, b"size_", self, duration=200)
self.__action = QAction("toogle-expanded", self, checkable=True)
self.__action.triggered[bool].connect(self.setExpanded)
def __init__(self, port=None):
QObject.__init__(self)
# Communication port must be provided or initialization will fail
if port == None:
raise ComError
try:
self.com = serial.Serial(timeout=0, baudrate=115200)
self.com.port = port
self.last_action = 'Port opened.'
except serial.SerialException:
self.last_action = 'Serial port already open.'
Device.num_devices += 1
def __init__(self, document, parent=None, deleteOnEnd=True):
QObject.__init__(self, parent)
self.document = document
self.scene = document.scene()
self.scheme = document.scheme()
self.deleteOnEnd = deleteOnEnd
self.cancelOnEsc = False
self.__finished = False
self.__canceled = False
self.__cancelReason = self.NoReason
def __init__(self, document, parent=None, deleteOnEnd=True):
QObject.__init__(self, parent)
self.document = document
self.scene = document.scene()
self.scheme = document.scheme()
self.deleteOnEnd = deleteOnEnd
self.cancelOnEsc = False
self.__finished = False
self.__canceled = False
self.__cancelReason = self.NoReason
def __init__(self, scatter_widget, parent=None, view_box=ViewBox):
QObject.__init__(self)
gui.OWComponent.__init__(self, scatter_widget)
self.subset_is_shown = False
self.view_box = view_box(self)
self.plot_widget = pg.PlotWidget(viewBox=self.view_box,
parent=parent,
background="w")
self.plot_widget.hideAxis("left")
self.plot_widget.hideAxis("bottom")
self.plot_widget.getPlotItem().buttonsHidden = True
self.plot_widget.setAntialiasing(True)
self.plot_widget.sizeHint = lambda: QSize(500, 500)
self.density_img = None
self.scatterplot_item = None
self.scatterplot_item_sel = None
self.labels = []
self.master = scatter_widget
self._create_drag_tooltip(self.plot_widget.scene())
self.selection = None # np.ndarray
self.n_valid = 0
self.n_shown = 0
self.sample_size = None
self.sample_indices = None
self.palette = None
self.shape_legend = self._create_legend(((1, 0), (1, 0)))
self.color_legend = self._create_legend(((1, 1), (1, 1)))
self.update_legend_visibility()
self.scale = None # DiscretizedScale
self._too_many_labels = False
# self.setMouseTracking(True)
# self.grabGesture(QPinchGesture)
# self.grabGesture(QPanGesture)
self.update_grid_visibility()
self._tooltip_delegate = EventDelegate(self.help_event)
self.plot_widget.scene().installEventFilter(self._tooltip_delegate)
self.view_box.sigTransformChanged.connect(self.update_density)
self.view_box.sigRangeChangedManually.connect(self.update_labels)
self.timer = None
def __init__(self, parent=None):
QObject.__init__(self, parent)
assert QThread.currentThread() is QApplication.instance().thread()
netmanager = self._NETMANAGER_REF and self._NETMANAGER_REF()
if netmanager is None:
netmanager = QNetworkAccessManager()
cache = QNetworkDiskCache()
cache.setCacheDirectory(
os.path.join(data_dir(), "geo", __name__ + ".GeoMap.Cache"))
netmanager.setCache(cache)
ImageLoader._NETMANAGER_REF = weakref.ref(netmanager)
self._netmanager = netmanager
def __init__(self, parent=None, title=None, description=None, env={}):
QObject.__init__(self, parent)
self.__title = title or ""
"Workflow title (empty string by default)."
self.__description = description or ""
"Workflow description (empty string by default)."
self.__annotations = []
self.__nodes = []
self.__links = []
self.__env = dict(env)
def __init__(self, scatter_widget, parent=None, view_box=ViewBox):
QObject.__init__(self)
gui.OWComponent.__init__(self, scatter_widget)
self.subset_is_shown = False
self.view_box = view_box(self)
self.plot_widget = pg.PlotWidget(viewBox=self.view_box, parent=parent,
background="w")
self.plot_widget.hideAxis("left")
self.plot_widget.hideAxis("bottom")
self.plot_widget.getPlotItem().buttonsHidden = True
self.plot_widget.setAntialiasing(True)
self.plot_widget.sizeHint = lambda: QSize(500, 500)
self.density_img = None
self.scatterplot_item = None
self.scatterplot_item_sel = None
self.labels = []
self.master = scatter_widget
self._create_drag_tooltip(self.plot_widget.scene())
self.selection = None # np.ndarray
self.n_valid = 0
self.n_shown = 0
self.sample_size = None
self.sample_indices = None
self.palette = None
self.shape_legend = self._create_legend(((1, 0), (1, 0)))
self.color_legend = self._create_legend(((1, 1), (1, 1)))
self.update_legend_visibility()
self.scale = None # DiscretizedScale
self._too_many_labels = False
# self.setMouseTracking(True)
# self.grabGesture(QPinchGesture)
# self.grabGesture(QPanGesture)
self.update_grid_visibility()
self._tooltip_delegate = EventDelegate(self.help_event)
self.plot_widget.scene().installEventFilter(self._tooltip_delegate)
self.view_box.sigTransformChanged.connect(self.update_density)
self.view_box.sigRangeChangedManually.connect(self.update_labels)
self.timer = None
def __init__(self, qpart):
QObject.__init__(self)
self._qpart = qpart
self._mode = Normal(self, qpart)
self._qpart.selectionChanged.connect(self._onSelectionChanged)
self._qpart.document().modificationChanged.connect(
self._onModificationChanged)
self._processingKeyPress = False
self.updateIndication()
self.lastEditCmdFunc = None
def __init__(self, parent=None):
QObject.__init__(self, parent)
self.__splitter = None
self.__widget = None
self.__updateOnShow = True # Need __update on next show event
self.__animationEnabled = True
self.__size = -1
self.__expanded = False
self.__animation = QPropertyAnimation(self,
b"size_",
self,
duration=200)
self.__action = QAction("toogle-expanded", self, checkable=True)
self.__action.triggered[bool].connect(self.setExpanded)
def __init__(self, description, title=None, position=None,
properties=None, parent=None):
QObject.__init__(self, parent)
self.description = description
if title is None:
title = description.name
self.__title = title
self.__position = position or (0, 0)
self.__progress = -1
self.__processing_state = 0
self.__status_message = ""
self.__state_messages = {}
self.properties = properties or {}
def __init__(self, parent=None):
QObject.__init__(self, parent)
assert QThread.currentThread() is QApplication.instance().thread()
netmanager = self._NETMANAGER_REF and self._NETMANAGER_REF()
if netmanager is None:
netmanager = QNetworkAccessManager()
cache = QNetworkDiskCache()
cache.setCacheDirectory(
os.path.join(settings.widget_settings_dir(),
__name__ + ".ImageLoader.Cache")
)
netmanager.setCache(cache)
ImageLoader._NETMANAGER_REF = weakref.ref(netmanager)
self._netmanager = netmanager
def setModel(self, model):
"""
Reimplemented.
Parameters
----------
model : QAbstractItemModel
"""
if model is self.__completerModel:
return
if self.__completerModel is not None:
self.__completerModel.dataChanged.disconnect(
self.__initDynamicModel)
self.__completerModel.rowsInserted.disconnect(
self.__initDynamicModel)
self.__completerModel.rowsRemoved.disconnect(
self.__initDynamicModel)
if QObject.parent(self.__completerModel) is self:
self.__completerModel.deleteLater()
self.__completerModel = None
self.__completerModel = model
if self.__completerModel is not None:
self.__completerModel.dataChanged.connect(
self.__initDynamicModel)
self.__completerModel.rowsInserted.connect(
self.__initDynamicModel)
self.__completerModel.rowsRemoved.connect(
self.__initDynamicModel)
self.__initDynamicModel()
def eventFilter(self, obj, event):
if (
obj is self.__widget
and event.type() == QEvent.Resize
and self.__animation.state() == QPropertyAnimation.Stopped
):
# Update the expanded state when the user opens/closes the widget
# by dragging the splitter handle.
if self.__splitter.orientation() == Qt.Vertical:
size = event.size().height()
else:
size = event.size().width()
if self.__expanded and size == 0:
self.__action.setChecked(False)
self.__expanded = False
elif not self.__expanded and size > 0:
self.__action.setChecked(True)
self.__expanded = True
if obj is self.__splitter and event.type() == QEvent.Show and self.__updateOnShow:
# Update the splitter state after receiving valid geometry
self.__updateOnShow = False
self.__update()
return QObject.eventFilter(self, obj, event)
def __init__(self, scheme):
assert scheme
QObject.__init__(self, scheme)
self._input_queue = []
# mapping a node to it's current outputs
# {node: {channel: {id: signal_value}}}
self._node_outputs = {}
self.__state = SignalManager.Running
self.__runtime_state = SignalManager.Waiting
# A flag indicating if UpdateRequest event should be rescheduled
self.__reschedule = False
self.__update_timer = QTimer(self, interval=100, singleShot=True)
self.__update_timer.timeout.connect(self.__process_next)
def setModel(self, model):
"""
Reimplemented.
Parameters
----------
model : QAbstractItemModel
"""
if model is self.__completerModel:
return
if self.__completerModel is not None:
self.__completerModel.dataChanged.disconnect(
self.__initDynamicModel)
self.__completerModel.rowsInserted.disconnect(
self.__initDynamicModel)
self.__completerModel.rowsRemoved.disconnect(
self.__initDynamicModel)
if QObject.parent(self.__completerModel) is self:
self.__completerModel.deleteLater()
self.__completerModel = None
self.__completerModel = model
if self.__completerModel is not None:
self.__completerModel.dataChanged.connect(self.__initDynamicModel)
self.__completerModel.rowsInserted.connect(self.__initDynamicModel)
self.__completerModel.rowsRemoved.connect(self.__initDynamicModel)
self.__initDynamicModel()
def eventFilter(self, viewport, event):
view = viewport.parent()
if event.type() == QEvent.MouseButtonPress and event.button() == Qt.LeftButton:
index = view.indexAt(event.pos())
if index is not None:
self._pos = event.pos()
self._index = QPersistentModelIndex(index)
elif (
event.type() == QEvent.MouseMove
and self._pos is not None
and ((self._pos - event.pos()).manhattanLength() >= QApplication.startDragDistance())
):
if self._index.isValid():
# Map to a QModelIndex in the model.
index = self._index
index = index.model().index(index.row(), index.column(), index.parent())
self._pos = None
self._index = None
self.dragStarted.emit(index)
return QObject.eventFilter(self, view, event)
def __init__(self, scheme):
assert(scheme)
QObject.__init__(self, scheme)
self._input_queue = []
# mapping a node to it's current outputs
# {node: {channel: {id: signal_value}}}
self._node_outputs = {}
self.__state = SignalManager.Running
self.__runtime_state = SignalManager.Waiting
# A flag indicating if UpdateRequest event should be rescheduled
self.__reschedule = False
self.__update_timer = QTimer(self, interval=100, singleShot=True)
self.__update_timer.timeout.connect(self.__process_next)
def _delete_widget(self, widget):
"""
Delete the OWBaseWidget instance.
"""
widget.close()
# Save settings to user global settings.
widget.saveSettings()
# Notify the widget it will be deleted.
widget.onDeleteWidget()
state = self.__widget_processing_state[widget]
if state & WidgetManager._DelayDeleteMask:
# If the widget is in an update loop and/or blocking we
# delay the scheduled deletion until the widget is done.
log.debug(
"Widget %s removed but still in state :%s. "
"Deferring deletion.", widget, state)
self.__delay_delete.add(widget)
else:
widget.deleteLater()
name = "{} '{}'".format(type(widget).__name__, widget.captionTitle)
if log.isEnabledFor(logging.DEBUG):
widget.destroyed.connect(
lambda: log.debug("Destroyed: %s", name))
widget.__marker = QObject()
widget.__marker.destroyed.connect(
lambda: log.debug("Destroyed namespace: %s", name))
del self.__widget_processing_state[widget]
def __init__(self, other_or_parent=None, parent=None):
if isinstance(other_or_parent, QObject) and parent is None:
parent, other_or_parent = other_or_parent, None
QObject.__init__(self, parent)
WidgetRegistry.__init__(self, other_or_parent)
# Should the QStandardItemModel be subclassed?
self.__item_model = QStandardItemModel(self)
for i, desc in enumerate(self.categories()):
cat_item = self._cat_desc_to_std_item(desc)
self.__item_model.insertRow(i, cat_item)
for j, wdesc in enumerate(self.widgets(desc.name)):
widget_item = self._widget_desc_to_std_item(wdesc, desc)
cat_item.insertRow(j, widget_item)
def __init__(self, other_or_parent=None, parent=None):
if isinstance(other_or_parent, QObject) and parent is None:
parent, other_or_parent = other_or_parent, None
QObject.__init__(self, parent)
WidgetRegistry.__init__(self, other_or_parent)
# Should the QStandardItemModel be subclassed?
self.__item_model = QStandardItemModel(self)
for i, desc in enumerate(self.categories()):
cat_item = self._cat_desc_to_std_item(desc)
self.__item_model.insertRow(i, cat_item)
for j, wdesc in enumerate(self.widgets(desc.name)):
widget_item = self._widget_desc_to_std_item(wdesc, desc)
cat_item.insertRow(j, widget_item)
def eventFilter(self, viewport, event):
view = viewport.parent()
if event.type() == QEvent.MouseButtonPress and \
event.button() == Qt.LeftButton:
index = view.indexAt(event.pos())
if index is not None:
self._pos = event.pos()
self._index = QPersistentModelIndex(index)
elif event.type() == QEvent.MouseMove and self._pos is not None and \
((self._pos - event.pos()).manhattanLength() >=
QApplication.startDragDistance()):
if self._index.isValid():
# Map to a QModelIndex in the model.
index = self._index
index = index.model().index(index.row(), index.column(),
index.parent())
self._pos = None
self._index = None
self.dragStarted.emit(index)
return QObject.eventFilter(self, view, event)
def eventFilter(self, obj, event):
if event.type() == QEvent.MouseButtonPress:
self.buttonDownPos = event.pos()
self.buttonDownObj = obj
self.button = event.button()
elif event.type() == QEvent.MouseMove and obj is self.buttonDownObj:
if (
self.buttonDownPos - event.pos()
).manhattanLength() > QApplication.startDragDistance() and not self.buttonDownObj.hitButton(
event.pos()
):
# Process the widget's mouse event, before starting the
# drag operation, so the widget can update its state.
obj.mouseMoveEvent(event)
self.dragStartOperationRequested.emit(obj)
obj.setDown(False)
self.button = None
self.buttonDownPos = None
self.buttonDownObj = None
return True # Already handled
return QObject.eventFilter(self, obj, event)
def __init__(self, master):
QObject.__init__(self)
OWComponent.__init__(self, master)
self.view = gui.TableView(wordWrap=True,
editTriggers=gui.TableView.NoEditTriggers)
header = self.view.horizontalHeader()
header.setSectionResizeMode(QHeaderView.ResizeToContents)
header.setDefaultAlignment(Qt.AlignCenter)
header.setStretchLastSection(False)
header.setContextMenuPolicy(Qt.CustomContextMenu)
header.customContextMenuRequested.connect(self.show_column_chooser)
self.model = QStandardItemModel(master)
self.model.setHorizontalHeaderLabels(["Method"])
self.view.setModel(self.model)
self.view.setItemDelegate(self.ItemDelegate())
def test_deref(self):
obj = QObject()
obj_wref = weakref.ref(obj)
ref = qobjref(obj)
del obj
assert ref() is obj_wref()
del ref
assert obj_wref() is None
def __init__(self, expression, globals={}, locals={}, parent=None):
QObject.__init__(self, parent)
self.ast = ast.parse(expression, mode="eval")
self.code = compile(self.ast, "<unknown>", "eval")
self.expression = expression
self.globals = dict(globals)
self.locals = dict(locals)
self._sources = {}
names = self.code.co_names
for name in names:
v = locals.get(name, globals.get(name))
if isinstance(v, AbstractBoundProperty):
self._sources[name] = v
v.changed.connect(self.notifyChanged)
v.destroyed.connect(self._on_destroyed)
def __init__(self, expression, globals={}, locals={}, parent=None):
QObject.__init__(self, parent)
self.ast = ast.parse(expression, mode="eval")
self.code = compile(self.ast, "<unknown>", "eval")
self.expression = expression
self.globals = dict(globals)
self.locals = dict(locals)
self._sources = {}
names = self.code.co_names
for name in names:
v = locals.get(name, globals.get(name))
if isinstance(v, AbstractBoundProperty):
self._sources[name] = v
v.changed.connect(self.notifyChanged)
v.destroyed.connect(self._on_destroyed)
def eventFilter(self, obj, event):
if obj is self.parent():
if event.type() == QEvent.GraphicsSceneMousePress:
return self.mousePressEvent(event)
elif event.type() == QEvent.GraphicsSceneMouseMove:
return self.mouseMoveEvent(event)
elif event.type() == QEvent.GraphicsSceneMouseRelease:
return self.mouseReleaseEvent(event)
return QObject.eventFilter(self, obj, event)
def customEvent(self, event):
QObject.customEvent(self, event)
if isinstance(event, SettingChangedEvent):
if event.type() == SettingChangedEvent.SettingChanged:
self.valueChanged.emit(event.key(), event.value())
elif event.type() == SettingChangedEvent.SettingAdded:
self.valueAdded.emit(event.key(), event.value())
elif event.type() == SettingChangedEvent.SettingRemoved:
self.keyRemoved.emit(event.key())
parent = self.parent()
if isinstance(parent, Settings):
# Assumption that the parent is a parent setting group.
parent.customEvent(
SettingChangedEvent(event.type(),
"/".join([self.__path,
event.key()]), event.value(),
event.oldValue()))
def eventFilter(self, obj, event):
if obj is self.parent():
if event.type() == QEvent.GraphicsSceneMousePress:
return self.mousePressEvent(event)
elif event.type() == QEvent.GraphicsSceneMouseMove:
return self.mouseMoveEvent(event)
elif event.type() == QEvent.GraphicsSceneMouseRelease:
return self.mouseReleaseEvent(event)
return QObject.eventFilter(self, obj, event)
def __init__(self,
description,
title=None,
position=None,
properties=None,
parent=None):
QObject.__init__(self, parent)
self.description = description
if title is None:
title = description.name
self.__title = title
self.__position = position or (0, 0)
self.__progress = -1
self.__processing_state = 0
self.__status_message = ""
self.__state_messages = {}
self.properties = properties or {}
def customEvent(self, event):
QObject.customEvent(self, event)
if isinstance(event, SettingChangedEvent):
if event.type() == SettingChangedEvent.SettingChanged:
self.valueChanged.emit(event.key(), event.value())
elif event.type() == SettingChangedEvent.SettingAdded:
self.valueAdded.emit(event.key(), event.value())
elif event.type() == SettingChangedEvent.SettingRemoved:
self.keyRemoved.emit(event.key())
parent = self.parent()
if isinstance(parent, Settings):
# Assumption that the parent is a parent setting group.
parent.customEvent(
SettingChangedEvent(event.type(),
"/".join([self.__path, event.key()]),
event.value(),
event.oldValue())
)
def __add__(self, iterable):
new_list = PyListModel(list(self._list),
# method parent is overloaded in Model
QObject.parent(self),
flags=self._flags,
list_item_role=self.list_item_role,
supportedDropActions=self.supportedDropActions())
# pylint: disable=protected-access
new_list._other_data = list(self._other_data)
new_list.extend(iterable)
return new_list
def eventFilter(self, receiver, event):
if event.type() == QEvent.Close and receiver is self.__scheme:
self.signal_manager().stop()
# Notify the widget instances.
for widget in list(self.__widget_for_node.values()):
widget.close()
widget.saveSettings()
widget.onDeleteWidget()
widget.deleteLater()
return QObject.eventFilter(self, receiver, event)
def customEvent(self, event):
"""
Reimplemented from `QObject.customEvent`.
"""
if event.type() == StateChangedEvent.StateChanged:
if event.state() == Future.Canceled:
self.cancelled.emit()
elif event.state() == Future.Running:
self.started.emit()
elif event.state() == Future.Finished:
self.finished.emit()
return
return QObject.customEvent(self, event)
def eventFilter(self, obj, event):
if event.type() == QEvent.StatusTip and \
not isinstance(event, QuickHelpTipEvent) and \
hasattr(obj, "whatsThis") and \
isinstance(obj.whatsThis, Callable):
tip = event.tip()
try:
text = obj.whatsThis()
except Exception:
text = None
if text:
ev = QuickHelpTipEvent(tip, text if tip else "")
return QCoreApplication.sendEvent(obj, ev)
return QObject.eventFilter(self, obj, event)
def eventFilter(self, obj, event):
etype = event.type()
if etype == QEvent.KeyPress:
key = event.key()
if key == Qt.Key_Down:
self.moveCurrent(1, 0)
return True
elif key == Qt.Key_Up:
self.moveCurrent(-1, 0)
return True
elif key == Qt.Key_Tab:
self.moveCurrent(0, 1)
return True
elif key == Qt.Key_Enter or key == Qt.Key_Return:
self.activateCurrent()
return True
return QObject.eventFilter(self, obj, event)
def test_dyn(self):
obj = QObject()
changed = []
binding = DynamicPropertyBinding(obj, "test")
binding.changed[object].connect(changed.append)
self.assertIs(binding.get(), None)
obj.setProperty("test", 1)
self.assertEqual(binding.get(), 1)
self.assertEqual(len(changed), 1)
self.assertEqual(changed[-1], 1)
binding.set(2)
self.assertEqual(binding.get(), 2)
self.assertEqual(len(changed), 2)
self.assertEqual(changed[-1], 2)
target = QObject()
binding1 = DynamicPropertyBinding(target, "prop")
binding1.bindTo(binding)
self.assertEqual(binding1.get(), binding.get())
self.assertEqual(target.property("prop"), 2)
binding.set("a string")
self.assertEqual(binding1.get(), "a string")
self.assertEqual(binding1.get(), binding.get())
self.assertEqual(target.property("prop"), "a string")
binding1.unbind()
binding.set(1)
self.assertEqual(binding1.get(), "a string")
self.assertEqual(target.property("prop"), "a string")
self.assertEqual(binding.get(), 1)
self.assertEqual(obj.property("test"), 1)
def eventFilter(self, obj, event):
if event.type() == QEvent.MouseButtonPress:
self.buttonDownPos = event.pos()
self.buttonDownObj = obj
self.button = event.button()
elif event.type() == QEvent.MouseMove and obj is self.buttonDownObj:
if (self.buttonDownPos - event.pos()).manhattanLength() > \
QApplication.startDragDistance() and \
not self.buttonDownObj.hitButton(event.pos()):
# Process the widget's mouse event, before starting the
# drag operation, so the widget can update its state.
obj.mouseMoveEvent(event)
self.dragStartOperationRequested.emit(obj)
obj.setDown(False)
self.button = None
self.buttonDownPos = None
self.buttonDownObj = None
return True # Already handled
return QObject.eventFilter(self, obj, event)
def __init__(self, parent=None, stream=None, **kwargs):
QObject.__init__(self, parent, **kwargs)
self._stream = stream
def __init__(self, parent=None, registry=None, cached_descriptions=None):
QObject.__init__(self, parent)
WidgetDiscovery.__init__(self, registry, cached_descriptions)
