def paintEvent(self, ev):
painter = QtGui.QPainter(self)
# calc bar offset
y_offset = (self.height() - self._barHeight()) // 2
## prevent negative offset
y_offset = 0 if y_offset < 0 else y_offset
# frame around fraction indicator
painter.setBrush(self.palette().dark())
painter.save()
## no fill color
b = painter.brush()
b.setStyle(QtCore.Qt.NoBrush)
painter.setBrush(b)
painter.drawRect(
QtCore.QRect(
QtCore.QPoint(0, y_offset),
QtCore.QSize(self._barWidth(), self._barHeight()),
))
painter.restore()
# fraction indicator
painter.drawRect(
QtCore.QRect(
QtCore.QPoint(0, y_offset),
QtCore.QSize(self._barWidth() * self._fraction,
self._barHeight()),
))
def paintArrow(self, paint, x, y, dir, color = QtCore.Qt.black):
dx1 = -5 # down
dx2 = +5
dy1 = -5
dy2 = -5
if (dir == 0): # right
dx1 = -5
dx2 = -5
dy1 = -5
dy2 = +5
elif (dir == 1): # up
dx1 = -5
dx2 = +5
dy1 = +5
dy2 = +5
elif (dir == 2): # left
dx1 = +5
dx2 = +5
dy1 = -5
dy2 = +5
pts = [QtCore.QPoint(x,y),
QtCore.QPoint(x + dx1,y + dy1),
QtCore.QPoint(x + dx2,y + dy2)]
poly = QtGui.QPolygon(pts)
paint.setBrush(color)
paint.drawPolygon(poly)
paint.setBrush(QtCore.Qt.NoBrush)
def __init__(self, parent=None):
QtWidgets.QTabBar.__init__(self, parent)
self.setAcceptDrops(True)
self.setElideMode(QtCore.Qt.ElideRight)
self.setSelectionBehaviorOnRemove(QtWidgets.QTabBar.SelectLeftTab)
self.dragStartPos = QtCore.QPoint()
self.dragDropedPos = QtCore.QPoint()
self.mouseCursor = QtGui.QCursor()
self.dragInitiated = False
def resizeEvent(self, ev):
if self.closeButton:
if self.orientation == 'vertical':
size = ev.size().width()
pos = QtCore.QPoint(0, 0)
else:
size = ev.size().height()
pos = QtCore.QPoint(ev.size().width() - size, 0)
self.closeButton.setFixedSize(QtCore.QSize(size, size))
self.closeButton.move(pos)
super(DockLabel, self).resizeEvent(ev)
def showEvent(self, event):
if (self.gas_or_air == "gas"):
point = self.window.gas_slider_label.rect().topLeft()
global_point = self.window.gas_slider_label.mapToGlobal(point)
self.move(global_point - QtCore.QPoint(self.width() - 120,
self.height() + 30))
else:
point = self.window.air_slider_label.rect().topLeft()
global_point = self.window.air_slider_label.mapToGlobal(point)
self.move(global_point - QtCore.QPoint(self.width() - 100,
self.height() + 30))
super(BorderLessDiaglogs, self).showEvent(event)
def setRB(self, ev = None, pen = None, brush = None):
if pen is not None and brush is not None:
if self.RB is not None:
self.RB.hide()
self.RB = None
if self.RB is None:
if pen is None: pen = self.defRbPen
if brush is None: brush = self.defRbBrush
self.RB = QtGui.QGraphicsRectItem(0, 0, 1, 1)
self.RB.setPen(pen)
self.RB.setBrush(brush)
self.RB.hide()
if ev is None: self.view.addItem(self.RB, ignoreBounds=True)
return
elif ev is None: # release mouse button
self.RB.hide()
return
if type(ev) is QtGuiQGraphicsMouseEvent:
self.XY1 = ev.pos()
self.keymod = ev.keymod
x0, y0 = self.XY0.x(), self.XY0.y()
x1, y1 = self.XY1.x(), self.XY1.y()
xY, yX = False, False
xr, yr = x0 > x1, y0 > y1 # Note: y are pixel values from top(left)
if self.keymod not in self.keyMod:
xY, yX = xr, yr
else:
xY = self.keymod == self.xyKeyMod[0]
yX = self.keymod == self.xyKeyMod[1]
if xY:
x0 = 0.
x1 = self.width()
if yX:
y0 = 0.
y1 = self.height()
X0, Y0 = self.mapxy(x0, y0, False) # bypasses axis
X1, Y1 = self.mapxy(x1, y1, False) # transformation
XY0 = QtCore.QPoint(X0, Y0)
XY1 = QtCore.QPoint(X1, Y1)
try: # to cope with old Qt4 versions.
rb = QtCore.QRectF(XY0, XY1)
except TypeError:
XY0 = QtCore.QPointF(X0, Y0)
XY1 = QtCore.QPointF(X1, Y1)
rb = QtCore.QRectF(XY0, XY1)
rb = self.childGroup.mapRectFromParent(rb)
self.RB.setPos(rb.topLeft())
self.RB.resetTransform()
self.RB.scale(rb.width(), rb.height())
self.RB.show()
def labelClicked(self):
if self.addList is None:
self.clicked.emit(self, None)
else:
w = self.addListPopup
pt = self.label.mapToGlobal(QtCore.QPoint(15, self.label.height()))
w.popup(pt)
def _doLayout(self, rect, testOnly):
x = rect.x()
y = rect.y()
lineHeight = 0
for item in self.itemList:
wid = item.widget()
spaceX = self.spacing() + wid.style().layoutSpacing(
QtGui.QSizePolicy.PushButton, QtGui.QSizePolicy.PushButton,
QtCore.Qt.Horizontal)
spaceY = self.spacing() + wid.style().layoutSpacing(
QtGui.QSizePolicy.PushButton, QtGui.QSizePolicy.PushButton,
QtCore.Qt.Vertical)
nextX = x + item.sizeHint().width() + spaceX
if nextX - spaceX > rect.right() and lineHeight > 0:
x = rect.x()
y = y + lineHeight + spaceY
nextX = x + item.sizeHint().width() + spaceX
lineHeight = 0
if not testOnly:
item.setGeometry(
QtCore.QRect(QtCore.QPoint(x, y), item.sizeHint()))
x = nextX
lineHeight = max(lineHeight, item.sizeHint().height())
return y + lineHeight - rect.y()
def itemClicked(self):
# popup menu when clicked
tw = self.tableWidget()
x = tw.verticalHeader().width() + tw.horizontalHeader(
).sectionPosition(tw.column(self))
y = tw.horizontalHeader().height() + tw.visualItemRect(self).bottom()
self.menu.popup(tw.mapToGlobal(QtCore.QPoint(x, y)))
def paint(self, painter, option, widget):
"""Paint this layer
:param painter: The painter object to draw with
:param option: Style information (unused)
:param widget: The widget that we are painting on
"""
try:
paths = self.path_visualization_buffer.get_nowait()
except queue.Empty as empty:
paths = self.cached_paths
self.cached_paths = paths
painter.setPen(pg.mkPen("b", width=2))
for path in paths.path:
polygon_points = [
QtCore.QPoint(
int(constants.MM_PER_M * point.x_meters),
int(constants.MM_PER_M * point.y_meters),
) for point in path.point
]
poly = QtGui.QPolygon(polygon_points)
painter.drawPolyline(poly)
def draw_validation(self, painter, validation):
"""Draw Validation
:param painter: The painter object to draw with
:param validation: Validation proto
"""
if validation.status == ValidationStatus.PASSING:
painter.setPen(pg.mkPen(Colors.VALIDATION_PASSED_COLOR, width=3))
if validation.status == ValidationStatus.FAILING:
painter.setPen(pg.mkPen(Colors.VALIDATION_FAILED_COLOR, width=3))
for circle in validation.geometry.circles:
painter.drawEllipse(
self.createCircle(
constants.MM_PER_M * circle.origin.x_meters,
constants.MM_PER_M * circle.origin.y_meters,
constants.MM_PER_M * circle.radius,
)
)
for polygon in validation.geometry.polygons:
polygon_points = [
QtCore.QPoint(
int(constants.MM_PER_M * point.x_meters),
int(constants.MM_PER_M * point.y_meters),
)
for point in polygon.points
]
poly = QtGui.QPolygon(polygon_points)
painter.drawPolygon(poly)
def paint(self, painter, option, widget):
"""Paint this layer
:param painter: The painter object to draw with
:param option: Style information (unused)
:param widget: The widget that we are painting on
"""
paths = self.path_receiver.maybe_pop()
if not paths:
paths = self.cached_paths
self.cached_paths = paths
painter.setPen(pg.mkPen("w"))
for path in paths.path:
polygon_points = [
QtCore.QPoint(
int(constants.MM_PER_M * point.x_meters),
int(constants.MM_PER_M * point.y_meters),
) for point in path.point
]
poly = QtGui.QPolygon(polygon_points)
painter.drawPolyline(poly)
def raiseContextMenu(self, ev):
menu = self.getMenu()
if menu is None:
return False
menu = self.scene().addParentContextMenus(self, menu, ev)
pos = ev.screenPos()
menu.popup(QtCore.QPoint(pos.x(), pos.y()))
return True
def raiseContextMenu(self, ev):
menu = self.getMenu()
## Make sure it is still ok to remove this handle
removeAllowed = all([r.checkRemoveHandle(self) for r in self.rois])
self.removeAction.setEnabled(removeAllowed)
pos = ev.screenPos()
menu.popup(QtCore.QPoint(pos.x(), pos.y()))
def itemClicked(self, col):
tw = self.treeWidget()
x = tw.header().sectionPosition(col)
y = tw.header().height() + tw.visualItemRect(self).bottom()
menu = self.internalMenu if self.solutions[col-1].type == 'internal' else self.externalMenu
menu.popup(tw.mapToGlobal(QtCore.QPoint(x, y)))
self._activeColumn = col
return None
def test_mouseInteraction():
# disable delay of mouse move events because events is called immediately in test
pg.setConfigOption('mouseRateLimit', -1)
plt = pg.plot()
plt.scene().minDragTime = 0 # let us simulate mouse drags very quickly.
vline = plt.addLine(x=0, movable=True)
hline = plt.addLine(y=0, movable=True)
hline2 = plt.addLine(y=-1, movable=False)
plt.setXRange(-10, 10)
plt.setYRange(-10, 10)
# test horizontal drag
pos = plt.plotItem.vb.mapViewToScene(pg.Point(0, 5)).toPoint()
pos2 = pos - QtCore.QPoint(200, 200)
mouseMove(plt, pos)
assert vline.mouseHovering is True and hline.mouseHovering is False
mouseDrag(plt, pos, pos2, QtCore.Qt.LeftButton)
px = vline.pixelLength(pg.Point(1, 0), ortho=True)
assert abs(vline.value() - plt.plotItem.vb.mapSceneToView(pos2).x()) <= px
# test missed drag
pos = plt.plotItem.vb.mapViewToScene(pg.Point(5, 0)).toPoint()
pos = pos + QtCore.QPoint(0, 6)
pos2 = pos + QtCore.QPoint(-20, -20)
mouseMove(plt, pos)
assert vline.mouseHovering is False and hline.mouseHovering is False
mouseDrag(plt, pos, pos2, QtCore.Qt.LeftButton)
assert hline.value() == 0
# test vertical drag
pos = plt.plotItem.vb.mapViewToScene(pg.Point(5, 0)).toPoint()
pos2 = pos - QtCore.QPoint(50, 50)
mouseMove(plt, pos)
assert vline.mouseHovering is False and hline.mouseHovering is True
mouseDrag(plt, pos, pos2, QtCore.Qt.LeftButton)
px = hline.pixelLength(pg.Point(1, 0), ortho=True)
assert abs(hline.value() - plt.plotItem.vb.mapSceneToView(pos2).y()) <= px
# test non-interactive line
pos = plt.plotItem.vb.mapViewToScene(pg.Point(5, -1)).toPoint()
pos2 = pos - QtCore.QPoint(50, 50)
mouseMove(plt, pos)
assert hline2.mouseHovering == False
mouseDrag(plt, pos, pos2, QtCore.Qt.LeftButton)
assert hline2.value() == -1
def itemClicked(self, col):
if col != 1:
return
tw = self.treeWidget()
x = tw.header().sectionPosition(col)
y = tw.header().height() + tw.visualItemRect(self).bottom()
self.menu.popup(tw.mapToGlobal(QtCore.QPoint(x, y)))
return None
def paintEvent(self, event):
if self.p:
painter = QtGui.QPainter(self)
painter.setViewport(self.centeredViewport(self.width(),
self.height()))
painter.setRenderHint(QtGui.QPainter.SmoothPixmapTransform)
rect = QtCore.QRect(QtCore.QPoint(0, 0), self.size())
painter.drawPixmap(rect, self.p)
def raiseContextMenu(self, ev):
"""
Raise the context menu
"""
if not self.menuEnabled():
return
menu = self.getMenu()
pos = ev.screenPos()
menu.popup(QtCore.QPoint(pos.x(), pos.y()))
def __init__(self, name, widget, size=(500, 500)):
'''create the base structure of a dock to hold widgets'''
super(WidgetDock, self).__init__(name, size=size, closable=True)
self.dockMenu = QtGui.QMenu()
self.label.sigClicked.connect(self._dockClick)
self.label.startedDrag = False # mandatory to handle label
self.label.pressPos = QtCore.QPoint(0, 0) # click events
self._make_base_actions()
self.addWidget(widget)
def raiseContextMenu(self, ev):
menu = self.scene().addParentContextMenus(self, self.getMenu(), ev)
pos = ev.screenPos()
menu.popup(QtCore.QPoint(pos.x(), pos.y()))
if self.connectedTo:
action = self.connectedTo.menuAction()
self.menu.removeAction(action)
del self.connectTo
def raiseContextMenu(self, ev):
menu = self.getContextMenus()
# Let the scene add on to the end of our context menu
# (this is optional)
menu = self.scene().addParentContextMenus(self, menu, ev)
pos = ev.screenPos()
menu.popup(QtCore.QPoint(pos.x(), pos.y()))
return True
def mouseMoveEvent(self, event):
"""
Moves the window with the mouse
:param event: The mouse event
:type event: QEvent
"""
if self.resizeGrip is not None and not self.resizeGrip.resizing:
delta = QtCore.QPoint(event.globalPos() - self.oldPos)
self.move(self.x() + delta.x(), self.y() + delta.y())
self.oldPos = event.globalPos()
def paintEvent(self, event):
size = self.size()
painter = QtGui.QPainter(self)
point = QtCore.QPoint(0, 0)
scaledPix = self.pixmap.scaled(
size,
QtCore.Qt.KeepAspectRatio,
transformMode=QtCore.Qt.SmoothTransformation)
# start painting the label from left upper corner
point.setX((size.width() - scaledPix.width()) / 2)
point.setY((size.height() - scaledPix.height()) / 2)
painter.drawPixmap(point, scaledPix)
def mouseMove(self, event):
"""Event handler for mouseMove events.
"""
pos = event.pos()
# Move traps
if self.group is not None:
self.moveGroup(pos)
# Update selection box
elif self.selection.isVisible():
region = QtCore.QRect(self.origin, QtCore.QPoint(pos)).normalized()
self.selection.setGeometry(region)
self.selectedTraps(region)
def raiseContextMenu(self, ev):
#print "viewbox.raiseContextMenu called."
#menu = self.getMenu(ev)
menu = self.getMenu(ev)
self.scene().addParentContextMenus(self, menu, ev)
#print "2:", [str(a.text()) for a in self.menu.actions()]
pos = ev.screenPos()
#pos2 = ev.scenePos()
#print "3:", [str(a.text()) for a in self.menu.actions()]
#self.sigActionPositionChanged.emit(pos2)
menu.popup(QtCore.QPoint(pos.x(), pos.y()))
def resizeEvent(self, ev):
# if self.Button1:
# if self.orientation == 'vertical':
# size = ev.size().width()
# pos = QtCore.QPoint(0, ev.size().height() - size)
# else:
# size = ev.size().height()
# pos = QtCore.QPoint(0, 0)
# self.button1.setFixedSize(QtCore.QSize(size, size))
# self.button1.move(pos)
if self.buttons:
for i in range(0, len(self.buttons)):
if self.orientation == 'vertical':
size = ev.size().width()
pos = QtCore.QPoint(0,
ev.size().height() - i * size - size)
else:
size = ev.size().height()
pos = QtCore.QPoint(i * size, 0)
self.buttons[i].setFixedSize(QtCore.QSize(size, size))
self.buttons[i].move(pos)
super(ColorDockLabel, self).resizeEvent(ev)
def __init__(self, data, color='w', fill=None):
pg.GraphicsObject.__init__(self)
self.data = data
# pre-computing a QPicture object allows paint() to run much more quickly,
# rather than re-drawing the shapes every time.
self.picture = QtGui.QPicture()
p = QtGui.QPainter(self.picture)
p.setPen(pg.mkPen(color=color))
if fill is not None: p.setBrush(pg.mkBrush(color=fill))
self.points = []
for item in self.data:
point = QtCore.QPoint(item[0], item[1])
self.points.append(point)
p.drawPolygon(*self.points)
p.end()
def leftPress(self, pos, modifiers):
"""Selection and grouping.
"""
self.group = self.clickedGroup(pos)
# update selection rectangle
if self.group is None:
self.origin = QtCore.QPoint(pos)
rect = QtCore.QRect(self.origin, QtCore.QSize())
self.selection.setGeometry(rect)
self.selection.show()
# break selected group
elif modifiers == QtCore.Qt.ControlModifier:
self.breakGroup()
# select group
else:
self.group.state = state.selected
self._update(project=False)
def mouseClickEvent(self, ev):
modifiers = QtGui.QApplication.keyboardModifiers()
if modifiers == QtCore.Qt.ShiftModifier and self._isLocked == False and ev.button(
) == QtCore.Qt.RightButton:
#self.setStyle("selected")
self.setState(self._isLocked,
self._empty,
self._updated,
self._remove_flag,
isSelected=True)
self.sigShiftMouseClicked.emit(self.id)
else:
self.sigMouseClicked.emit(self.id)
menu = self.getMenu()
pos = ev.screenPos()
menu.popup(QtCore.QPoint(pos.x(), pos.y()))
