def __init__(self, parent=None):
QTabBar.__init__(self, parent)
self.setAcceptDrops(True)
self.setElideMode(Qt.ElideRight)
self.setSelectionBehaviorOnRemove(QTabBar.SelectLeftTab)
self.drag_start_pos = QPoint()
self.drag_droped_pos = QPoint()
self.mouse_cursor = QCursor()
self.drag_initiated = False
def mousePressEvent(self, QMouseEvent):
cursor = QCursor()
x = QMouseEvent.x()
y = QMouseEvent.y()
if (x < 1280 and y < 720) and (x > 15 and y > 15):
if self._rubber == None:
if not self.frozen:
self.freeze()
self.frozen_before = False
else:
self.frozen_before = True
self.rub_origin = QMouseEvent.pos()
self._rubber = QRubberBand(QRubberBand.Rectangle, self)
self._rubber.show()
self.crop_stat = IMG
elif (x > 1300 and y > 520) and (x < 1907 and y < 1010):
self.rub_origin = QMouseEvent.pos()
self._rubber = QRubberBand(QRubberBand.Rectangle, self)
self._rubber.show()
if QMouseEvent.button(
) == Qt.RightButton and self.selected_count != 0:
self.select_status = HIST_DESELECTION
else:
self.select_status = HIST_SELECTION
self.crop_stat = HIST
self.log_info("hist status {}".format("HSV" if self.hist_status ==
HSV else "LAB"))
def _add_exclude_filter(self, filter_index=False):
"""
:param filter_index: if false then this function shows a QMenu to allow the user to choose a
type of message filter. ''bool''
OR
:param filter_index: the index of the filter to be added, ''int''
:return: if a filter was added then the index is returned, ''int''
OR
:return: if no filter was added then None is returned, ''NoneType''
"""
if filter_index is False:
filter_index = -1
filter_select_menu = QMenu()
for index in self._filter_factory_order:
# flattens the _exclude filters list and only adds the item if it doesn't
# already exist
if index in ['message', 'location'] or \
not self.filter_factory[index][1] in \
[type(item) for sublist in self._exclude_filters for item in sublist]:
filter_select_menu.addAction(self.filter_factory[index][0])
action = filter_select_menu.exec_(QCursor.pos())
if action is None:
return None
for index in self._filter_factory_order:
if self.filter_factory[index][0] == action.text():
filter_index = index
if filter_index == -1:
return None
index = len(self._exclude_filters)
newfilter = self.filter_factory[filter_index][1]()
if len(self.filter_factory[filter_index]) >= 4:
newwidget = self.filter_factory[filter_index][2](
newfilter, self._rospack, self.filter_factory[filter_index][3])
else:
newwidget = self.filter_factory[filter_index][2](newfilter,
self._rospack)
# pack the new filter tuple onto the filter list
self._exclude_filters.append(
(newfilter,
FilterWrapperWidget(newwidget,
self.filter_factory[filter_index][0]),
filter_index))
self._proxy_model.add_exclude_filter(newfilter)
newfilter.filter_changed_signal.connect(
self._proxy_model.handle_exclude_filters_changed)
self._exclude_filters[index][1].delete_button.clicked.connect(
self._delete_exclude_filter)
self._model.rowsInserted.connect(
self._exclude_filters[index][1].repopulate)
# place the widget in the proper location
self.exclude_table.insertRow(index)
self.exclude_table.setCellWidget(index, 0,
self._exclude_filters[index][1])
self.exclude_table.resizeColumnsToContents()
self.exclude_table.resizeRowsToContents()
newfilter.filter_changed_signal.emit()
return index
def on_mouse_up(self, event):
self._paused = False
if self._selecting_mode in [_SelectionMode.LEFT_MARKED, _SelectionMode.MOVE_LEFT, _SelectionMode.MOVE_RIGHT, _SelectionMode.SHIFTING]:
if self._selected_left is None:
self._selecting_mode = _SelectionMode.NONE
else:
self._selecting_mode = _SelectionMode.MARKED
self.scene().views()[0].setCursor(QCursor(Qt.ArrowCursor))
self.scene().update()
def mouseMoveEvent(self, QMouseEvent):
cursor = QCursor()
x = QMouseEvent.x()
y = QMouseEvent.y()
# if in coords of image and crop status is image then draw the rect
if self._rubber is None:
return
if (x < 1280 and y < 720) and (x > 15
and y > 15) and self.crop_stat == IMG:
self._rubber.setGeometry(
QRect(self.rub_origin, QMouseEvent.pos()).normalized())
# if in coords of hist and crop status is hist then draw the rect
elif (x > 1300 and y > 520) and (x < 1907 and
y < 1010) and self.crop_stat == HIST:
self._rubber.setGeometry(
QRect(self.rub_origin, QMouseEvent.pos()).normalized())
def _add_exclude_filter(self, filter_index=False):
"""
:param filter_index: if false then this function shows a QMenu to allow the user to choose a type of message filter. ''bool''
OR
:param filter_index: the index of the filter to be added, ''int''
:return: if a filter was added then the index is returned, ''int''
OR
:return: if no filter was added then None is returned, ''NoneType''
"""
if filter_index is False:
filter_index = -1
filter_select_menu = QMenu()
for index in self._filter_factory_order:
# flattens the _exclude filters list and only adds the item if it doesn't already exist
if index in ['message', 'location'] or not self.filter_factory[index][1] in [type(item) for sublist in self._exclude_filters for item in sublist]:
filter_select_menu.addAction(self.filter_factory[index][0])
action = filter_select_menu.exec_(QCursor.pos())
if action is None:
return None
for index in self._filter_factory_order:
if self.filter_factory[index][0] == action.text():
filter_index = index
if filter_index == -1:
return None
index = len(self._exclude_filters)
newfilter = self.filter_factory[filter_index][1]()
if len(self.filter_factory[filter_index]) >= 4:
newwidget = self.filter_factory[filter_index][2](newfilter, self._rospack, self.filter_factory[filter_index][3])
else:
newwidget = self.filter_factory[filter_index][2](newfilter, self._rospack)
# pack the new filter tuple onto the filter list
self._exclude_filters.append((newfilter, FilterWrapperWidget(newwidget, self.filter_factory[filter_index][0]), filter_index))
self._proxy_model.add_exclude_filter(newfilter)
newfilter.filter_changed_signal.connect(self._proxy_model.handle_exclude_filters_changed)
self._exclude_filters[index][1].delete_button.clicked.connect(self._delete_exclude_filter)
self._model.rowsInserted.connect(self._exclude_filters[index][1].repopulate)
# place the widget in the proper location
self.exclude_table.insertRow(index)
self.exclude_table.setCellWidget(index, 0, self._exclude_filters[index][1])
self.exclude_table.resizeColumnsToContents()
self.exclude_table.resizeRowsToContents()
newfilter.filter_changed_signal.emit()
return index
def on_left_down(self, event):
if self.playhead == None:
return
self._clicked_pos = self._dragged_pos = event.pos()
self.pause()
if event.modifiers() == Qt.ShiftModifier:
return
x = self._clicked_pos.x()
y = self._clicked_pos.y()
if x >= self._history_left and x <= self._history_right:
if y >= self._history_top and y <= self._history_bottom:
# Clicked within timeline - set playhead
playhead_secs = self.map_x_to_stamp(x)
if playhead_secs <= 0.0:
self.playhead = rospy.Time(0, 1)
else:
self.playhead = rospy.Time.from_sec(playhead_secs)
self.scene().update()
elif y <= self._history_top:
# Clicked above timeline
if self._selecting_mode == _SelectionMode.NONE:
self._selected_left = None
self._selected_right = None
self._selecting_mode = _SelectionMode.LEFT_MARKED
self.scene().update()
self.emit_play_region()
elif self._selecting_mode == _SelectionMode.MARKED:
left_x = self.map_stamp_to_x(self._selected_left)
right_x = self.map_stamp_to_x(self._selected_right)
if x < left_x - self._selection_handle_width or x > right_x + self._selection_handle_width:
self._selected_left = None
self._selected_right = None
self._selecting_mode = _SelectionMode.LEFT_MARKED
self.scene().update()
self.emit_play_region()
elif self._selecting_mode == _SelectionMode.SHIFTING:
self.scene().views()[0].setCursor(
QCursor(Qt.ClosedHandCursor))
def _on_ctrl_info(self, index):
popup = self._popup_widget
ctrl = self._controllers[index.row()]
popup.ctrl_name.setText(ctrl.name)
popup.ctrl_type.setText(ctrl.type)
res_model = QStandardItemModel()
model_root = QStandardItem('Claimed Resources')
res_model.appendRow(model_root)
for hw_res in ctrl.claimed_resources:
hw_iface_item = QStandardItem(hw_res.hardware_interface)
model_root.appendRow(hw_iface_item)
for res in hw_res.resources:
res_item = QStandardItem(res)
hw_iface_item.appendRow(res_item)
popup.resource_tree.setModel(res_model)
popup.resource_tree.setItemDelegate(FontDelegate(popup.resource_tree))
popup.resource_tree.expandAll()
popup.move(QCursor.pos())
popup.show()
def _on_ctrl_info(self, index):
popup = self._popup_widget
ctrl = self._controllers[index.row()]
popup.ctrl_name.setText(ctrl.name)
popup.ctrl_type.setText(ctrl.type)
res_model = QStandardItemModel()
model_root = QStandardItem('Claimed Resources')
res_model.appendRow(model_root)
for hw_res in ctrl.claimed_resources:
hw_iface_item = QStandardItem(hw_res.hardware_interface)
model_root.appendRow(hw_iface_item)
for res in hw_res.resources:
res_item = QStandardItem(res)
hw_iface_item.appendRow(res_item)
popup.resource_tree.setModel(res_model)
popup.resource_tree.setItemDelegate(FontDelegate(popup.resource_tree))
popup.resource_tree.expandAll()
popup.move(QCursor.pos())
popup.show()
def showEvent(self, event):
geom = self.frameGeometry()
geom.moveTopLeft(QCursor.pos())
self.setGeometry(geom)
super(QDialog, self).showEvent(event)
def on_mouse_move(self, event):
if not self._history_left: # TODO: need a better notion of initialized
return
x = event.pos().x()
y = event.pos().y()
if event.buttons() == Qt.NoButton:
# Mouse moving
if self._selecting_mode in [_SelectionMode.MARKED, _SelectionMode.MOVE_LEFT, _SelectionMode.MOVE_RIGHT, _SelectionMode.SHIFTING]:
if y <= self._history_top and self._selected_left is not None:
left_x = self.map_stamp_to_x(self._selected_left)
right_x = self.map_stamp_to_x(self._selected_right)
if abs(x - left_x) <= self._selection_handle_width:
self._selecting_mode = _SelectionMode.MOVE_LEFT
self.scene().views()[0].setCursor(QCursor(Qt.SizeHorCursor))
return
elif abs(x - right_x) <= self._selection_handle_width:
self._selecting_mode = _SelectionMode.MOVE_RIGHT
self.scene().views()[0].setCursor(QCursor(Qt.SizeHorCursor))
return
elif x > left_x and x < right_x:
self._selecting_mode = _SelectionMode.SHIFTING
self.scene().views()[0].setCursor(QCursor(Qt.OpenHandCursor))
return
else:
self._selecting_mode = _SelectionMode.MARKED
self.scene().views()[0].setCursor(QCursor(Qt.ArrowCursor))
else:
# Mouse dragging
if event.buttons() == Qt.MidButton or event.modifiers() == Qt.ShiftModifier:
# Middle or shift: zoom and pan
dx_drag, dy_drag = x - self._dragged_pos.x(), y - self._dragged_pos.y()
if dx_drag != 0:
self.translate_timeline(-self.map_dx_to_dstamp(dx_drag))
if (dx_drag == 0 and abs(dy_drag) > 0) or (dx_drag != 0 and abs(float(dy_drag) / dx_drag) > 0.2 and abs(dy_drag) > 1):
zoom = min(self._max_zoom_speed, max(self._min_zoom_speed, 1.0 + self._zoom_sensitivity * dy_drag))
self.zoom_timeline(zoom, self.map_x_to_stamp(x))
self.scene().views()[0].setCursor(QCursor(Qt.ClosedHandCursor))
elif event.buttons() == Qt.LeftButton:
# Left: move selected region and move selected region boundry
clicked_x = self._clicked_pos.x()
clicked_y = self._clicked_pos.y()
x_stamp = self.map_x_to_stamp(x)
if y <= self._history_top:
if self._selecting_mode == _SelectionMode.LEFT_MARKED:
# Left and selecting: change selection region
clicked_x_stamp = self.map_x_to_stamp(clicked_x)
self._selected_left = min(clicked_x_stamp, x_stamp)
self._selected_right = max(clicked_x_stamp, x_stamp)
self.scene().update()
elif self._selecting_mode == _SelectionMode.MOVE_LEFT:
self._selected_left = x_stamp
self.scene().update()
elif self._selecting_mode == _SelectionMode.MOVE_RIGHT:
self._selected_right = x_stamp
self.scene().update()
elif self._selecting_mode == _SelectionMode.SHIFTING:
dx_drag = x - self._dragged_pos.x()
dstamp = self.map_dx_to_dstamp(dx_drag)
self._selected_left = max(self._start_stamp.to_sec(), min(self._end_stamp.to_sec(), self._selected_left + dstamp))
self._selected_right = max(self._start_stamp.to_sec(), min(self._end_stamp.to_sec(), self._selected_right + dstamp))
self.scene().update()
self.emit_play_region()
elif clicked_x >= self._history_left and clicked_x <= self._history_right and clicked_y >= self._history_top and clicked_y <= self._history_bottom:
# Left and clicked within timeline: change playhead
if x_stamp <= 0.0:
self.playhead = rospy.Time(0, 1)
else:
self.playhead = rospy.Time.from_sec(x_stamp)
self.scene().update()
self._dragged_pos = event.pos()
def mouseReleaseEvent(self, QMouseEvent):
cursor = QCursor()
x = QMouseEvent.x()
y = QMouseEvent.y()
if self._rubber is None:
return
if (x < 1280 and y < 720) and (x > 15
and y > 15) and self.crop_stat == IMG:
if not self.frozen_before:
self.freeze()
a = self.mapToGlobal(self.rub_origin)
b = QMouseEvent.globalPos()
a = self.wdg_img.mapFromGlobal(a)
b = self.wdg_img.mapFromGlobal(b)
self._rubber.hide()
self._rubber = None
pix = QPixmap(self.wdg_img.pixmap())
sx = float(self.wdg_img.rect().width())
sy = float(self.wdg_img.rect().height())
# h 1080 w 1920
sx = self.orig_w / sx
sy = self.orig_h / sy
a.setX(int(a.x() * sx))
a.setY(int(a.y() * sy))
b.setX(int(b.x() * sx))
b.setY(int(b.y() * sy))
rect_ = QRect(a, b)
h_ = rect_.height()
w_ = rect_.width()
y1, x1, y2, x2 = rect_.getCoords()
rospy.loginfo('Img cropped x1 {} y1 {} x2 {} y2{}'.format(
x1, y1, x2, y2))
self.log_info('Img cropped x1 {} y1 {} x2 {} y2{}'.format(
x1, y1, x2, y2))
self.capture_cropped(x1, y1, x2, y2)
elif (x > 1300 and y > 520) and (x < 1907 and
y < 1010) and self.crop_stat == HIST:
# h 1080 w 1920
if self.hist_status == HSV:
cur_hist = self.inner_hist
elif self.hist_status == LUV:
cur_hist = self.inner_luv_hist
# if not self.frozen_before:
# self.freeze()
a = self.mapToGlobal(self.rub_origin)
b = QMouseEvent.globalPos()
a = cur_hist.mapFromGlobal(a)
b = cur_hist.mapFromGlobal(b)
self._rubber.hide()
self._rubber = None
pix = QPixmap(cur_hist.pixmap())
sx = float(cur_hist.rect().width())
sy = float(cur_hist.rect().height())
# h 1080 w 1920
if self.hist_status == HSV:
sx = self.hist_hsv_orig_w / sx
sy = self.hist_hsv_orig_h / sy
elif self.hist_status == LUV:
sx = self.hist_lab_orig_w / sx
sy = self.hist_lab_orig_h / sy
a.setX(int(a.x() * sx))
a.setY(int(a.y() * sy))
b.setX(int(b.x() * sx))
b.setY(int(b.y() * sy))
rect_ = QRect(a, b)
h_ = rect_.height()
w_ = rect_.width()
# y1,x1,y2,x2 = rect_.getCoords()
x1, y1, x2, y2 = rect_.getCoords()
rospy.loginfo('Hist cropped x1 {} y1 {} x2 {} y2 {}'.format(
x1, y1, x2, y2))
self.log_info('Hist cropped x1 {} y1 {} x2 {} y2 {}'.format(
x1, y1, x2, y2))
if self.select_status == HIST_SELECTION:
self.select_hist(x1, y1, x2, y2, h_, w_, self.hist_status)
elif self.select_status == HIST_DESELECTION:
self.deselect_hist(x1, y1, x2, y2, self.hist_status)
else:
if self._rubber is not None:
self._rubber.hide()
self._rubber = None
self.crop_stat = 0
class DetachableTabBar(QTabBar):
'''
The TabBar class re-implements some of the functionality of the QTabBar widget
'''
detach_tab_signal = Signal(int, QPoint, bool) # tab at pos, mouse cursor position, by double click
move_tab_signal = Signal(int, int)
empty_signal = Signal()
def __init__(self, parent=None):
QTabBar.__init__(self, parent)
self.setAcceptDrops(True)
self.setElideMode(Qt.ElideRight)
self.setSelectionBehaviorOnRemove(QTabBar.SelectLeftTab)
self.drag_start_pos = QPoint()
self.drag_droped_pos = QPoint()
self.mouse_cursor = QCursor()
self.drag_initiated = False
def mouseDoubleClickEvent(self, event):
'''
Send the detach_tab_signal when a tab is double clicked
'''
event.accept()
self.detach_tab_signal.emit(self.tabAt(event.pos()), self.mouse_cursor.pos(), True)
def mousePressEvent(self, event):
'''
Set the starting position for a drag event when the mouse button is pressed
'''
self.drag_droped_pos = QPoint(0, 0)
self.drag_initiated = False
if event.button() == Qt.LeftButton:
self.drag_start_pos = event.pos()
QTabBar.mousePressEvent(self, event)
def mouseMoveEvent(self, event):
'''
Determine if the current movement is a drag. If it is, convert it into a QDrag. If the
drag ends inside the tab bar, emit an move_tab_signal. If the drag ends outside the tab
bar, emit an detach_tab_signal.
'''
# Determine if the current movement is detected as a drag
if not self.drag_start_pos.isNull() and ((event.pos() - self.drag_start_pos).manhattanLength() > QApplication.startDragDistance()):
self.drag_initiated = True
# If the current movement is a drag initiated by the left button
if ((event.buttons() & Qt.LeftButton)) and self.drag_initiated:
# Stop the move event
finishMoveEvent = QMouseEvent(QEvent.MouseMove, event.pos(), Qt.NoButton, Qt.NoButton, Qt.NoModifier)
QTabBar.mouseMoveEvent(self, finishMoveEvent)
# Convert the move event into a drag
drag = QDrag(self)
mime_data = QMimeData()
mime_data.setData('action', b'application/tab-detach')
drag.setMimeData(mime_data)
# Create the appearance of dragging the tab content
# tab_index = self.tabAt(self.drag_start_pos)
pixmap = self.parentWidget().grab()
targetPixmap = QPixmap(pixmap.size())
targetPixmap.fill(Qt.transparent)
painter = QPainter(targetPixmap)
painter.setOpacity(0.85)
painter.drawPixmap(0, 0, pixmap)
painter.end()
drag.setPixmap(targetPixmap)
# Initiate the drag
dropAction = drag.exec_(Qt.MoveAction | Qt.CopyAction)
# If the drag completed outside of the tab bar, detach the tab and move
# the content to the current cursor position
if dropAction == Qt.IgnoreAction:
event.accept()
self.detach_tab_signal.emit(self.tabAt(self.drag_start_pos), self.mouse_cursor.pos(), False)
elif dropAction == Qt.MoveAction:
# else if the drag completed inside the tab bar, move the selected tab to the new position
if not self.drag_droped_pos.isNull():
self.move_tab_signal.emit(self.tabAt(self.drag_start_pos), self.tabAt(self.drag_droped_pos))
else:
# else if the drag completed inside the tab bar new TabBar, move the selected tab to the new TabBar
self.detach_tab_signal.emit(self.tabAt(self.drag_start_pos), self.mouse_cursor.pos(), False)
event.accept()
else:
QTabBar.mouseMoveEvent(self, event)
def dragEnterEvent(self, event):
'''
Determine if the drag has entered a tab position from another tab position
'''
self.drag_droped_pos = QPoint(0, 0)
mime_data = event.mimeData()
formats = mime_data.formats()
if 'action' in formats and mime_data.data('action') == 'application/tab-detach':
event.acceptProposedAction()
QTabBar.dragMoveEvent(self, event)
def dropEvent(self, event):
'''
Get the position of the end of the drag
'''
self.drag_droped_pos = event.pos()
mime_data = event.mimeData()
formats = mime_data.formats()
if 'action' in formats and mime_data.data('action') == 'application/tab-detach':
event.acceptProposedAction()
QTabBar.dropEvent(self, event)
def prepared_for_drop(self):
return not self.drag_droped_pos.isNull()
def tabRemoved(self, index):
QTabBar.tabRemoved(self, index)
if self.count() == 0:
self.empty_signal.emit()