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, 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, 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_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, 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, 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, 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, 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 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 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 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)