def eventFilter(self, obj: QObject, event: QEvent) -> bool:
"""Event filter to process an event for the given destination.
In this case, this widget listens for Enter events on the application level
(during this widget's init, this eventFilter is installed on the app instance).
When the destination object is a QWidget,
we can try to update this widget's help_text with the destination widget's what's this help text.
If there is no what's this text, we set the help_text back to its placeholderText.
"""
if event.type() == QEvent.Enter:
if isinstance(obj, QWidget):
help_text = obj.whatsThis()
# When the obj has help text, let's update the help text widget
if help_text != "":
self._help_display.setText(help_text)
# Store a ref to the entered widget so we can maintain the help text if its children don't have any
self._cached_entered_widget = weakref.ref(obj)
if event.type() == QEvent.Leave:
if isinstance(obj, QWidget):
# When we leave a widget, if it didn't have help text,
# we want to check if the previously cached (entered) widget is its ancestor.
# This will maintain the ancestor's help text in the help text widget when the child has not help text.
if obj.whatsThis() == "":
# Revert to placeholder text when we have left a widget and the cached widget is not its ancestor
# (i.e. the previously entered widget with help text is not related).
if not self._is_child_of_previously_entered_widget_with_help_text(
obj):
self._help_display.setText(
self._help_display.placeholderText())
return super(HelpWidget, self).eventFilter(obj, event)
def editorEvent(
self,
event: QtCore.QEvent,
model: QtCore.QAbstractItemModel,
option: QStyleOptionViewItem,
index: QtCore.QModelIndex,
) -> bool:
"""Called when an event has occured in the editor.
This can be used to customize how the delegate handles mouse/key events
"""
if (event.type() == event.MouseButtonRelease
and event.button() == Qt.RightButton):
self.show_context_menu(index, model, event.globalPos(),
option.widget)
# if the user clicks quickly on the visibility checkbox, we *don't*
# want it to be interpreted as a double-click. We want the visibilty
# to simply be toggled.
if event.type() == event.MouseButtonDblClick:
self.initStyleOption(option, index)
style = option.widget.style()
check_rect = style.subElementRect(
style.SE_ItemViewItemCheckIndicator, option, option.widget)
if check_rect.contains(event.pos()):
cur_state = index.data(Qt.CheckStateRole)
if model.flags(index) & Qt.ItemIsUserTristate:
state = Qt.CheckState((cur_state + 1) % 3)
else:
state = Qt.Unchecked if cur_state else Qt.Checked
return model.setData(index, state, Qt.CheckStateRole)
# refer all other events to the QStyledItemDelegate
return super().editorEvent(event, model, option, index)
def sceneEventFilter(self, event: QtCore.QEvent) -> bool:
# call the inherited method
if MaskTool.sceneEventFilter(self, event):
return True
if self.parent.maskTypeChooser.active_draw_type is None:
return True
# Mouse wheel to change the cursor size
if event.type() == QtCore.QEvent.GraphicsSceneWheel:
try: # PyQt 5
angle = event.angleDelta().y()
except AttributeError: # PyQt 4
angle = event.delta()
# wheel with CTRL means changing the cursor size
if event.modifiers() == QtCore.Qt.ControlModifier:
if angle > 0:
self.parent.changeCursorSize(+1)
else:
self.parent.changeCursorSize(-1)
event.accept()
return True
# Mouse press starts drawing
if event.type() == QtCore.QEvent.GraphicsSceneMousePress and event.button() == QtCore.Qt.LeftButton:
# if no mask has been created, create one for painting
if self.parent.MaskEmpty is True:
self.parent.AddEmptyMask()
# store the coordinates
self.last_x = event.pos().x()
self.last_y = event.pos().y()
# add a first circle (so that even if the mouse isn't moved something is drawn)
self.DrawLine(self.last_x, self.last_x + 0.00001, self.last_y, self.last_y)
# set the changed flag for the database
self.parent.data_file.setChangesMade()
# accept the event
return True
if event.type() == QtCore.QEvent.GraphicsSceneMouseRelease and event.button() == QtCore.Qt.LeftButton:
if self.parent.config.auto_mask_update:
with self.parent.window.changeTracker("draw line in mask"):
self.parent.save()
# Mouse move event to draw the stroke
if event.type() == QtCore.QEvent.GraphicsSceneMouseMove:
# get the new position
self.parent.DrawCursor.setPos(event.pos())
pos_x = event.pos().x()
pos_y = event.pos().y()
# draw a line and store the position
self.DrawLine(pos_x, self.last_x, pos_y, self.last_y)
self.last_x = pos_x
self.last_y = pos_y
# accept the event
return True
# Mouse hover updates the color_under_cursor and displays the brush cursor
if event.type() == QtCore.QEvent.GraphicsSceneHoverMove:
# move brush cursor
self.parent.DrawCursor.setPos(event.pos())
# don't accept the event, so that others can accept it
return False
def eventFilter(self, object: QLineEdit, event: QEvent):
if event.type() == QEvent.FocusIn:
object.setFrame(True)
object.setReadOnly(False)
return True
if event.type() == QEvent.FocusOut:
if object.text():
object.setFrame(False)
object.setReadOnly(True)
return True
return False
def _handle_edit(self, event: QtCore.QEvent):
"""Handle closing edit box and redisplayin label"""
if event.type() == QtCore.QEvent.Type.KeyPress:
key = event.key()
if key in (QtCore.Qt.Key.Key_Return, QtCore.Qt.Key.Key_Enter):
if not self.edit.hasAcceptableInput():
self.setCurrentWidget(self.label)
return
self.label.setText(self.edit.text())
self.setCurrentWidget(self.label)
self.valueChanged.emit(self.label.text())
if key == QtCore.Qt.Key.Key_Escape:
self.setCurrentWidget(self.label)
elif event.type() == QtCore.QEvent.FocusOut:
self.setCurrentWidget(self.label)
def event(self, e: QEvent) -> bool:
'''
Event
Parameters
----------
e : QEvent
Returns
-------
value : bool
'''
state = self.d.dragging_state
if state == DragState.inactive:
# Normally we would check here, if the left mouse button is pressed.
# But from QT version 5.12.2 on the mouse events from
# QEvent.NonClientAreaMouseButtonPress return the wrong mouse
# button The event always returns Qt.RightButton even if the left
# button is clicked.
if e.type() == QEvent.NonClientAreaMouseButtonPress:
if QT_VERSION_TUPLE >= (5, 12, 2):
# and QGuiApplication.mouseButtons().testFlag(Qt.LeftButton ...
logger.debug('FloatingWidget.event Event.NonClientAreaMouseButtonPress %s', e.type())
self.d.set_state(DragState.mouse_pressed)
elif QGuiApplication.mouseButtons() == Qt.LeftButton:
logger.debug('FloatingWidget.event Event.NonClientAreaMouseButtonPress %s', e.type())
self.d.set_state(DragState.mouse_pressed)
elif state == DragState.mouse_pressed:
if e.type() == QEvent.NonClientAreaMouseButtonDblClick:
logger.debug('FloatingWidget.event QEvent.NonClientAreaMouseButtonDblClick')
self.d.set_state(DragState.inactive)
elif e.type() == QEvent.Resize:
# If the first event after the mouse press is a resize event, then
# the user resizes the window instead of dragging it around.
# But there is one exception. If the window is maximized,
# then dragging the window via title bar will cause the widget to
# leave the maximized state. This in turn will trigger a resize event.
# To know, if the resize event was triggered by user via moving a
# corner of the window frame or if it was caused by a windows state
# change, we check, if we are not in maximized state.
if not self.isMaximized():
self.d.set_state(DragState.inactive)
elif state == DragState.floating_widget:
if e.type() == QEvent.NonClientAreaMouseButtonRelease:
logger.debug('FloatingWidget.event QEvent.NonClientAreaMouseButtonRelease')
self.d.title_mouse_release_event()
return super().event(e)
def event(self, event: QEvent):
if event.type() == QEvent.WindowActivate and self.isVisible():
self.update_profile_list()
self.update_spacing()
self.multiple_files_chk.setChecked(
self._settings.get("multiple_files_widget", False))
return super().event(event)
def _handle_label(self, event: QtCore.QEvent):
"""Display QLineEdit if label is double clicked"""
if event.type() == QtCore.QEvent.Type.MouseButtonDblClick:
self.edit.setText(self.label.text())
self.setCurrentWidget(self.edit)
self.edit.selectAll()
self.edit.setFocus()
def event(self, event: QEvent):
if event.type() == QEvent.WindowActivate:
index = self.components.currentRow()
self.components.clear()
self.components.addItems(list(map(str, self.get_parameters.keys())))
self.components.setCurrentRow(index)
return super().event(event)
def editorEvent(self, event: QtCore.QEvent,
model: QtCore.QAbstractItemModel,
option: 'QStyleOptionViewItem',
index: QtCore.QModelIndex) -> bool:
decorationRect = option.rect
if event.type() == QEvent.MouseButtonPress:
item = index.model().data(index, Qt.UserRole)
if isinstance(item, QVariant):
return QStyledItemDelegate.editorEvent(self, event, model,
option, index)
type = item['type']
value = item['value']
if type == 'device_activity':
text_rect = calculate_text_rect(
value['device'], font=ResourceLoader().qt_font_text_xs)
if calculate_middle_rect(decorationRect,
text_rect.width(),
text_rect.height(),
x=110,
y=15).contains(event.pos()):
print('点击了设备{device}'.format(device=value['device']))
return QStyledItemDelegate.editorEvent(self, event, model, option,
index)
def eventFilter(self, watched: QObject, event: QEvent) -> bool:
'''
Eventfilter
Parameters
----------
watched : QObject
Unused
event : QEvent
Returns
-------
value : bool
'''
#pylint: disable=unused-argument
if event.type() == QEvent.MouseButtonRelease:
logger.debug('MouseButtonRelease')
if self.d.dragging_state == DragState.floating_widget:
qapp = QApplication.instance()
qapp.removeEventFilter(self)
logger.debug('FloatingWidget.eventFilter QEvent.MouseButtonRelease')
self.finish_dragging()
self.d.title_mouse_release_event()
return False
def event(self, e: QEvent) -> bool:
'''
Emits titleChanged signal if title change event occurs
Parameters
----------
e : QEvent
Returns
-------
value : bool
'''
if e.type() == QEvent.WindowTitleChange:
title = self.windowTitle()
if self.d.tab_widget:
self.d.tab_widget.setText(title)
if self.d.toggle_view_action:
self.d.toggle_view_action.setText(title)
if self.d.dock_area:
# update tabs menu
self.d.dock_area.mark_title_bar_menu_outdated()
self.title_changed.emit(title)
return super().event(e)
def changeEvent(self, event: QEvent):
"""Change event handler.
Args:
event (QEvent): Event.
"""
if event.type() == QEvent.StyleChange:
self.setHtml(qrainbowstyle.rainbowize(OpenStreetMapsHtml.html))
return super().changeEvent(event)
def event(self, event: QEvent):
if event.type() == QEvent.WindowActivate:
# update combobox for segmentation
self.update_combo_box(self.choose_profile, self._settings.segmentation_profiles)
# update combobox for pipeline
self.update_combo_box(self.choose_pipe, self._settings.segmentation_pipelines)
self.update_tooltips()
return super().event(event)
def event(self, event: QEvent) -> bool:
if event.type() == QEvent.WindowActivate:
if self.settings.image is not None:
self.channel_select.change_channels_num(
self.settings.image.channels)
self.refresh_measurements()
return super().event(event)
def changeEvent(self, event: QEvent):
"""Change event handler.
Args:
event (QEvent): Event.
"""
if event.type() == QEvent.StyleChange:
self.setColor(qrainbowstyle.getCurrentPalette().COLOR_ACCENT_4)
def eventFilter(self, qobject: QObject, event: QEvent) -> bool:
if event.type() == QEvent.ToolTipChange and isinstance(
qobject, QWidget):
tooltip = qobject.toolTip()
if tooltip and not qt_might_be_rich_text(tooltip):
qobject.setToolTip(f'<qt>{html.escape(tooltip)}</qt>')
return True
return super().eventFilter(qobject, event)
def changeEvent(self, event: QEvent) -> None:
if event.type(
) == QEvent.WindowStateChange and not qrainbowstyle.USE_DARWIN_BUTTONS:
if self.isMaximized():
self.__bar.showRestoreButton(True)
self.__bar.showMaximizeButton(False)
else:
self.__bar.showRestoreButton(False)
self.__bar.showMaximizeButton(True)
return super().changeEvent(event)
def sceneEventFilter(self, event: QtCore.QEvent) -> bool:
if MaskTool.sceneEventFilter(self, event):
return True
# Mouse press starts drawing
if event.type() == QtCore.QEvent.GraphicsSceneMousePress and event.button() == QtCore.Qt.LeftButton:
self.PickColor()
# accept the event
return True
# Mouse hover updates the color_under_cursor and displays the brush cursor
if event.type() == QtCore.QEvent.GraphicsSceneHoverMove:
# get color at this position
if self.parent.MaskEmpty is True:
self.color_under_cursor = 0
else:
color = self.parent.MaskDisplay.GetColor(event.pos().x(), event.pos().y())
if color is not None:
self.color_under_cursor = color
# don't accept the event, so that others can accept it
return False
def changeEvent(self, event: QEvent):
"""Change event handler.
Args:
event (QEvent): Event.
"""
if event.type() == QEvent.StyleChange:
self.setHtml(
qrainbowstyle.rainbowize(
GoogleMapsHtml.html.replace("API_KEY_GOES_HERE",
self.api_key)))
return super().changeEvent(event)
def event(self, event: QEvent):
if event.type() == QEvent.ToolTip and self.components:
# text = str(self.component)
text_list = []
for el in self.components:
if self.settings.component_is_chosen(el):
text_list.append("☑{}".format(el))
else:
text_list.append("☐{}".format(el))
QToolTip.showText(event.globalPos(), " ".join(text_list))
return super().event(event)
def eventFilter(self, tab: QObject, event: QEvent) -> bool:
'''
Filters the tab widget events
Parameters
----------
tab : QObject
event : QEvent
Returns
-------
value : bool
'''
result = super().eventFilter(tab, event)
if isinstance(tab, DockWidgetTab):
if event.type() == QEvent.Hide:
self.tab_closed.emit(self.d.tabs_layout.indexOf(tab))
elif event.type() == QEvent.Show:
self.tab_opened.emit(self.d.tabs_layout.indexOf(tab))
return result
def event(self, evt: QtCore.QEvent) -> bool:
# Capture the Tab keypress
if evt.type() in (QtCore.QEvent.KeyPress, QtCore.QEvent.KeyRelease):
kevt = cast(QtGui.QKeyEvent, evt)
if kevt.key() in (QtCore.Qt.Key_Tab, QtCore.Qt.Key_Up,
QtCore.Qt.Key_Down):
if kevt.type() == QtCore.QEvent.KeyRelease:
self.keyReleaseEvent(kevt)
kevt.accept()
return True
return super(ConsoleEditWidget, self).event(evt)
def sceneEventFilter(self, event: QtCore.QEvent) -> bool:
if MaskTool.sceneEventFilter(self, event):
return True
# Mouse press starts drawing
if event.type() == QtCore.QEvent.GraphicsSceneMousePress and event.button() == QtCore.Qt.LeftButton:
with self.parent.window.changeTracker("bucket fill in mask"):
self.fillColor(event.pos().x(), event.pos().y())
self.parent.save()
# accept the event
return True
# don't accept the event, so that others can accept it
return False
def event(self, e: QEvent) -> bool:
'''
Handles activation events to update zOrderIndex
Parameters
----------
e : QEvent
Returns
-------
value : bool
'''
result = super().event(e)
global _z_order_counter # TODO
if e.type() == QEvent.WindowActivate:
_z_order_counter += 1
self.d.z_order_index = _z_order_counter
elif e.type() == QEvent.Show and not self.d.z_order_index:
_z_order_counter += 1
self.d.z_order_index = _z_order_counter
return result
def changeEvent(self, event: QEvent):
'''
Changeevent
Parameters
----------
event : QEvent
'''
super().changeEvent(event)
if (event.type() == QEvent.ActivationChange) and self.isActiveWindow():
logger.debug('FloatingWidget.changeEvent QEvent.ActivationChange ')
global _z_order_counter # TODO
_z_order_counter += 1
self.d.z_order_index = _z_order_counter
def sceneEventFilter(self, event: QtCore.QEvent) -> None:
if event.type() == QtCore.QEvent.GraphicsSceneWheel:
try: # PyQt 5
angle = event.angleDelta().y()
except AttributeError: # PyQt 4
angle = event.delta()
# wheel with SHIFT means changing the opacity
if event.modifiers() == QtCore.Qt.ShiftModifier:
if angle > 0:
self.parent.changeOpacity(+0.1)
else:
self.parent.changeOpacity(-0.1)
event.accept()
return True
def eventFilter(self, target: Any, qevent: QtCore.QEvent) -> bool:
if self.interactionDelegate is None:
return False
if qevent.type() == QtCore.QEvent.KeyPress:
q_key_event = cast(QtGui.QKeyEvent, qevent)
event_id = EventID.from_key_event(q_key_event)
modifiers = Modifier.from_qevent(qevent)
ate_event = self.dispatchActionEvent(self.lastPoint, event_id, modifiers)
if ate_event:
self.update()
return ate_event
return False
def event(self, e: QEvent) -> bool:
'''
Track event ToolTipChange and set child ToolTip
Parameters
----------
e : QEvent
Returns
-------
value : bool
'''
if e.type() == QEvent.ToolTipChange:
text = self.toolTip()
self.d.title_label.setToolTip(text)
return super().event(e)
def event(self, e: QEvent) -> bool:
'''
Handle polish events
Parameters
----------
e : QEvent
Returns
-------
value : bool
'''
result = super().event(e)
if e.type() == QEvent.Polish:
self.d.cross.setup_overlay_cross(self.d.mode)
return result
