def create_polygon_path(data):
path = QPainterPath()
polygon = QPolygonF()
for pt in data.get('points'):
polygon.append(pt)
path.addPolygon(polygon)
return path
def create_ellipse_path(data):
path = QPainterPath()
path.addEllipse(QPointF(data.get('cx'), data.get('cy')), data.get('rx'),
data.get('ry'))
if 'transform' in data:
m = re.match('^matrix\\((.+)\\)$', data.get('transform'))
if m:
args = map(lambda x: float(x), m.group(1).split())
if len(args) == 6:
transform = QTransform(*args)
path *= transform
return path
def paintEvent(base_button, event):
painter = QStylePainter(base_button)
painter.setRenderHint(QPainter.Antialiasing)
option = QStyleOption()
option.initFrom(base_button)
x = option.rect.x()
y = option.rect.y()
height = option.rect.height() - 1
width = option.rect.width() - 1
gradient = BaseButtonStyle._gradient[NORMAL]
offset = 0
if base_button.isDown():
gradient = BaseButtonStyle._gradient[DOWN]
offset = 1
elif not base_button.isEnabled():
gradient = BaseButtonStyle._gradient[DISABLED]
painter.setPen(base_button._pens_border)
painter.drawEllipse(x + 1, y + 1, width - 1, height - 1)
painter.setPen(base_button._pens_clear)
painter.setBrush(gradient[OUTER])
painter.drawEllipse(x + 2, y + 2, width - 3, height - 2)
painter.setBrush(gradient[INNER])
painter.drawEllipse(x + 3, y + 3, width - 5, height - 4)
painter.setBrush(base_button._brush_clear)
line_path = QPainterPath()
line_path.moveTo(x + 8, y + 8)
line_path.lineTo(x + 12, x + 12)
line_path.moveTo(x + 12, y + 8)
line_path.lineTo(x + 8, y + 12)
painter.setPen(base_button._pens_border)
painter.drawPath(line_path)
glow_index = base_button._glow_index
glow_pens = base_button._glow_pens
if glow_index > 0:
for index in range(3):
painter.setPen(glow_pens[glow_index][index])
painter.drawPath(line_path)
painter.setPen(glow_pens[glow_index][3])
painter.drawPath(line_path)
def paint(self, painter, option, widget=None):
path = QPainterPath()
path.addRoundedRect(self.m_rect, 5, 5)
anchor = self.mapFromParent(self.m_chart.mapToPosition(self.m_anchor))
if not self.m_rect.contains(anchor):
point1 = QPointF()
point2 = QPointF()
# establish the position of the anchor point in relation to m_rect
above = anchor.y() <= self.m_rect.top()
aboveCenter = (anchor.y() > self.m_rect.top()
and anchor.y() <= self.m_rect.center().y())
belowCenter = (anchor.y() > self.m_rect.center().y()
and anchor.y() <= self.m_rect.bottom())
below = anchor.y() > self.m_rect.bottom()
onLeft = anchor.x() <= self.m_rect.left()
leftOfCenter = (anchor.x() > self.m_rect.left()
and anchor.x() <= self.m_rect.center().x())
rightOfCenter = (anchor.x() > self.m_rect.center().x()
and anchor.x() <= self.m_rect.right())
onRight = anchor.x() > self.m_rect.right()
# get the nearest m_rect corner.
x = (onRight + rightOfCenter) * self.m_rect.width()
y = (below + belowCenter) * self.m_rect.height()
cornerCase = ((above and onLeft) or (above and onRight)
or (below and onLeft) or (below and onRight))
vertical = abs(anchor.x() - x) > abs(anchor.y() - y)
x1 = (x + leftOfCenter * 10 - rightOfCenter * 20 +
cornerCase * int(not vertical) *
(onLeft * 10 - onRight * 20))
y1 = (y + aboveCenter * 10 - belowCenter * 20 +
cornerCase * int(vertical) * (above * 10 - below * 20))
point1.setX(x1)
point1.setY(y1)
x2 = (x + leftOfCenter * 20 - rightOfCenter * 10 +
cornerCase * int(not vertical) *
(onLeft * 20 - onRight * 10))
y2 = (y + aboveCenter * 20 - belowCenter * 10 +
cornerCase * int(vertical) * (above * 20 - below * 10))
point2.setX(x2)
point2.setY(y2)
path.moveTo(point1)
path.lineTo(anchor)
path.lineTo(point2)
path = path.simplified()
painter.setBrush(QColor(255, 255, 255))
painter.drawPath(path)
painter.drawText(self.m_textRect, self.m_text)
def update_path(self, points):
self._points = points
bezier_path = QPainterPath()
bezier_path.moveTo(points[0])
bezier_path.cubicTo(*points[1:])
self._rect = bezier_path.boundingRect()
self.setPath(bezier_path)
def drawFreeLine(self, pointPath, result):
tmp = [
ACTION_FREEPEN,
QPainterPath(pointPath),
QPen(QColor(self.penColorNow), int(self.penSizeNow))
]
if result:
self.drawListResult.append(tmp)
else:
self.drawListProcess = tmp
def mousePressEvent(self, event):
"""
:type event: QMouseEvent
:param event:
:return:
"""
if event.button() != Qt.LeftButton:
return
if self.action is None:
self.action = ACTION_SELECT
self.startX, self.startY = event.x(), event.y()
if self.action == ACTION_SELECT:
if self.mousePosition == MousePosition.OUTSIDE_AREA:
self.mousePressed = True
self.selectedArea = QRect()
self.selectedArea.setTopLeft(QPoint(event.x(), event.y()))
self.selectedArea.setBottomRight(QPoint(event.x(), event.y()))
self.redraw()
elif self.mousePosition == MousePosition.INSIDE_AREA:
self.mousePressed = True
else:
pass
elif self.action == ACTION_MOVE_SELECTED:
if self.mousePosition == MousePosition.OUTSIDE_AREA:
self.action = ACTION_SELECT
self.selectedArea = QRect()
self.selectedArea.setTopLeft(QPoint(event.x(), event.y()))
self.selectedArea.setBottomRight(QPoint(event.x(), event.y()))
self.redraw()
self.mousePressed = True
elif self.action in DRAW_ACTION:
self.mousePressed = True
if self.action == ACTION_FREEPEN:
self.pointPath = QPainterPath()
self.pointPath.moveTo(QPoint(event.x(), event.y()))
elif self.action == ACTION_TEXT:
if self.textPosition is None:
self.textPosition = QPoint(event.x(), event.y())
self.textRect = None
self.redraw()
def create_rect_path(data):
path = QPainterPath()
if data.get('rx') > 0 or data.get('ry'):
path.addRoundedRect(data.get('x'), data.get('y'), data.get('w'),
data.get('h'), data.get('rx'), data.get('ry'))
else:
path.addRect(data.get('x'), data.get('y'), data.get('w'),
data.get('h'))
if 'transform' in data:
m = re.match('^matrix\\((.+)\\)$', data.get('transform'))
if m:
args = map(lambda x: float(x), m.group(1).split())
if len(args) == 6:
transform = QTransform(*args)
path *= transform
return path
def paintEvent(self, event: QPaintEvent) -> None:
p = QPainter(self)
self.m_normalMap.render(p, event.rect())
p.setPen(Qt.black)
p.drawText(
self.rect(),
Qt.AlignBottom | Qt.TextWordWrap,
"Map data CCBYSA 2009 OpenStreetMap.org contributors",
)
p.end()
if self.zoomed:
dim = min(self.width(), self.height())
magnifierSize = min(MAX_MAGNIFIER, dim * 2 / 3)
radius = magnifierSize / 2
ring = radius - 15
box = QSize(magnifierSize, magnifierSize)
if self.maskPixmap.size() != box:
self.maskPixmap = QPixmap(box)
self.maskPixmap.fill(Qt.transparent)
g = QRadialGradient()
g.setCenter(radius, radius)
g.setFocalPoint(radius, radius)
g.setRadius(radius)
g.setColorAt(1.0, QColor(255, 255, 255, 0))
g.setColorAt(0.5, QColor(128, 128, 128, 255))
mask = QPainter(self.maskPixmap)
mask.setRenderHint(QPainter.Antialiasing)
mask.setCompositionMode(QPainter.CompositionMode_Source)
mask.setBrush(g)
mask.setPen(Qt.NoPen)
mask.drawRect(self.maskPixmap.rect())
mask.setBrush(QColor(Qt.transparent))
mask.drawEllipse(g.center(), ring, ring)
mask.end()
center = self.dragPos - QPoint(0, radius)
center = center + QPoint(0, radius / 2)
corner = center - QPoint(radius, radius)
xy = center * 2 - QPoint(radius, radius)
# only set the dimension to the magnified portion
if self.zoomPixmap.size() != box:
zoomPixmap = QPixmap(box)
zoomPixmap.fill(Qt.lightGray)
if True:
p = QPainter(zoomPixmap)
p.translate(-xy)
self.m_largeMap.render(p, QRect(xy, box))
p.end()
clipPath = QPainterPath()
clipPath.addEllipse(center, ring, ring)
p = QPainter(self)
p.setRenderHint(QPainter.Antialiasing)
p.setClipPath(clipPath)
p.drawPixmap(corner, zoomPixmap)
p.setClipping(False)
p.drawPixmap(corner, self.maskPixmap)
p.setPen(Qt.gray)
p.drawPath(clipPath)
if self.invert:
p = QPainter(self)
p.setCompositionMode(QPainter.CompositionMode_Difference)
p.fillRect(event.rect(), Qt.white)
p.end()
def __init__(self, flags=constant.DEFAULT, parent=None):
"""
flags: binary flags. see the flags in the constant.py
"""
super(Screenshot, self).__init__(parent)
self._screen = 0
# Init
self.penColorNow = QColor(PENCOLOR)
self.penSizeNow = PENSIZE
self.fontNow = QFont('Sans')
self.clipboard = QApplication.clipboard()
self.drawListResult = [
] # draw list that sure to be drew, [action, coord]
self.drawListProcess = None # the process to the result
self.selectedArea = QRect(
) # a QRect instance which stands for the selected area
self.selectedAreaRaw = QRect()
self.mousePosition = MousePosition.OUTSIDE_AREA # mouse position
self.screenPixel = None
self.textRect = None
self.mousePressed = False
self.action = ACTION_SELECT
self.mousePoint = self.cursor().pos()
self.startX, self.startY = 0, 0 # the point where you start
self.endX, self.endY = 0, 0 # the point where you end
self.pointPath = QPainterPath(
) # the point mouse passes, used by draw free line
self.itemsToRemove = [
] # the items that should not draw on screenshot picture
self.textPosition = None
# result
self.target_img = None
# Init window
self.getscreenshot()
self.setWindowFlags(Qt.WindowStaysOnTopHint | Qt.FramelessWindowHint)
self.setMouseTracking(True)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setContentsMargins(0, 0, 0, 0)
self.setStyleSheet("QGraphicsView { border-style: none; }")
self.tooBar = MyToolBar(flags, self)
self.tooBar.trigger.connect(self.changeAction)
self.penSetBar = None
if flags & constant.RECT or flags & constant.ELLIPSE or flags & constant.LINE or flags & constant.FREEPEN \
or flags & constant.ARROW or flags & constant.TEXT:
self.penSetBar = PenSetWidget(self)
self.penSetBar.penSizeTrigger.connect(self.changePenSize)
self.penSetBar.penColorTrigger.connect(self.changePenColor)
self.penSetBar.fontChangeTrigger.connect(self.changeFont)
self.textInput = TextInput(self)
self.textInput.inputChanged.connect(self.textChange)
self.textInput.cancelPressed.connect(self.cancelInput)
self.textInput.okPressed.connect(self.okInput)
print('======>>> {0}, {1}'.format(self.screenPixel.width(),
self.screenPixel.height()))
self.graphicsScene = QGraphicsScene(0, 0, self.screenPixel.width(),
self.screenPixel.height())
# self.show()
# self.setScene(self.graphicsScene)
# self.windowHandle().setScreen(QGuiApplication.screenAt(QCursor.pos()))
# self.scale = self.get_scale()
# # self.setFixedSize(self.screenPixel.width(), self.screenPixel.height())
# # screen = QApplication.desktop().screenNumber(QApplication.desktop().cursor().pos())
# # _rect = QDesktopWidget().availableGeometry(screen=screen)
# # self.setGeometry(_rect)
# self.setGeometry(QGuiApplication.screenAt(QCursor.pos()).geometry())
# self.showFullScreen()
# self.redraw()
self._show()
QShortcut(QKeySequence('ctrl+s'),
self).activated.connect(self.saveScreenshot)
QShortcut(QKeySequence('esc'), self).activated.connect(self.close)
class Screenshot(QGraphicsView):
""" Main Class """
screen_shot_grabed = Signal(QImage)
widget_closed = Signal()
def __init__(self, flags=constant.DEFAULT, parent=None):
"""
flags: binary flags. see the flags in the constant.py
"""
super(Screenshot, self).__init__(parent)
self._screen = 0
# Init
self.penColorNow = QColor(PENCOLOR)
self.penSizeNow = PENSIZE
self.fontNow = QFont('Sans')
self.clipboard = QApplication.clipboard()
self.drawListResult = [
] # draw list that sure to be drew, [action, coord]
self.drawListProcess = None # the process to the result
self.selectedArea = QRect(
) # a QRect instance which stands for the selected area
self.selectedAreaRaw = QRect()
self.mousePosition = MousePosition.OUTSIDE_AREA # mouse position
self.screenPixel = None
self.textRect = None
self.mousePressed = False
self.action = ACTION_SELECT
self.mousePoint = self.cursor().pos()
self.startX, self.startY = 0, 0 # the point where you start
self.endX, self.endY = 0, 0 # the point where you end
self.pointPath = QPainterPath(
) # the point mouse passes, used by draw free line
self.itemsToRemove = [
] # the items that should not draw on screenshot picture
self.textPosition = None
# result
self.target_img = None
# Init window
self.getscreenshot()
self.setWindowFlags(Qt.WindowStaysOnTopHint | Qt.FramelessWindowHint)
self.setMouseTracking(True)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setContentsMargins(0, 0, 0, 0)
self.setStyleSheet("QGraphicsView { border-style: none; }")
self.tooBar = MyToolBar(flags, self)
self.tooBar.trigger.connect(self.changeAction)
self.penSetBar = None
if flags & constant.RECT or flags & constant.ELLIPSE or flags & constant.LINE or flags & constant.FREEPEN \
or flags & constant.ARROW or flags & constant.TEXT:
self.penSetBar = PenSetWidget(self)
self.penSetBar.penSizeTrigger.connect(self.changePenSize)
self.penSetBar.penColorTrigger.connect(self.changePenColor)
self.penSetBar.fontChangeTrigger.connect(self.changeFont)
self.textInput = TextInput(self)
self.textInput.inputChanged.connect(self.textChange)
self.textInput.cancelPressed.connect(self.cancelInput)
self.textInput.okPressed.connect(self.okInput)
print('======>>> {0}, {1}'.format(self.screenPixel.width(),
self.screenPixel.height()))
self.graphicsScene = QGraphicsScene(0, 0, self.screenPixel.width(),
self.screenPixel.height())
# self.show()
# self.setScene(self.graphicsScene)
# self.windowHandle().setScreen(QGuiApplication.screenAt(QCursor.pos()))
# self.scale = self.get_scale()
# # self.setFixedSize(self.screenPixel.width(), self.screenPixel.height())
# # screen = QApplication.desktop().screenNumber(QApplication.desktop().cursor().pos())
# # _rect = QDesktopWidget().availableGeometry(screen=screen)
# # self.setGeometry(_rect)
# self.setGeometry(QGuiApplication.screenAt(QCursor.pos()).geometry())
# self.showFullScreen()
# self.redraw()
self._show()
QShortcut(QKeySequence('ctrl+s'),
self).activated.connect(self.saveScreenshot)
QShortcut(QKeySequence('esc'), self).activated.connect(self.close)
def _show(self):
# self._screen = QApplication.desktop().screenNumber(QApplication.desktop().cursor().pos())
self.getscreenshot()
self.show()
self.setScene(self.graphicsScene)
# self.windowHandle().setScreen(QGuiApplication.screenAt(QCursor.pos()))
self.scale = self.get_scale()
# self.setGeometry(QGuiApplication.screenAt(QCursor.pos()).geometry())
screenGeometry = QApplication.primaryScreen().virtualGeometry()
self.setGeometry(screenGeometry.x(), screenGeometry.y(),
screenGeometry.width(), screenGeometry.height())
# self.showFullScreen()
self.redraw()
@staticmethod
def take_screenshot(flags, parent=None):
loop = QEventLoop()
screen_shot = Screenshot(flags, parent)
screen_shot.show()
screen_shot.widget_closed.connect(loop.quit)
loop.exec_()
img = screen_shot.target_img
return img
def getscreenshot(self):
# screen = QGuiApplication.screenAt(QApplication.desktop().cursor().pos())
# self.screenPixel = screen.grabWindow(0)
# dw = QtWidgets.QApplication.desktop()
# self.screenPixel = QPixmap.grabWindow( dw.winId(), 0, 0, dw.width(), dw.height() )
screenGeometry = QApplication.primaryScreen().virtualGeometry()
try:
self.screenPixel = QApplication.primaryScreen().grabWindow(
QApplication.desktop().winId(), screenGeometry.x(),
screenGeometry.y(), screenGeometry.width(),
screenGeometry.height())
except:
self.screenPixel = QApplication.primaryScreen().grabWindow(
int(QApplication.desktop().winId()), screenGeometry.x(),
screenGeometry.y(), screenGeometry.width(),
screenGeometry.height())
# QRect screenGeometry = qApp->primaryScreen()->virtualGeometry();
# QPixmap screenPixmap = qApp->primaryScreen()->grabWindow(qApp->desktop()->winId(), screenGeometry.x(), screenGeometry.y(), screenGeometry.width(), screenGeometry.height());
def mousePressEvent(self, event):
"""
:type event: QMouseEvent
:param event:
:return:
"""
if event.button() != Qt.LeftButton:
return
if self.action is None:
self.action = ACTION_SELECT
self.startX, self.startY = event.x(), event.y()
if self.action == ACTION_SELECT:
if self.mousePosition == MousePosition.OUTSIDE_AREA:
self.mousePressed = True
self.selectedArea = QRect()
self.selectedArea.setTopLeft(QPoint(event.x(), event.y()))
self.selectedArea.setBottomRight(QPoint(event.x(), event.y()))
self.redraw()
elif self.mousePosition == MousePosition.INSIDE_AREA:
self.mousePressed = True
else:
pass
elif self.action == ACTION_MOVE_SELECTED:
if self.mousePosition == MousePosition.OUTSIDE_AREA:
self.action = ACTION_SELECT
self.selectedArea = QRect()
self.selectedArea.setTopLeft(QPoint(event.x(), event.y()))
self.selectedArea.setBottomRight(QPoint(event.x(), event.y()))
self.redraw()
self.mousePressed = True
elif self.action in DRAW_ACTION:
self.mousePressed = True
if self.action == ACTION_FREEPEN:
self.pointPath = QPainterPath()
self.pointPath.moveTo(QPoint(event.x(), event.y()))
elif self.action == ACTION_TEXT:
if self.textPosition is None:
self.textPosition = QPoint(event.x(), event.y())
self.textRect = None
self.redraw()
def mouseMoveEvent(self, event):
"""
:type event: QMouseEvent
:param event:
:return:
"""
# _screen = QApplication.desktop().screenNumber(QApplication.desktop().cursor().pos())
# if self._screen != _screen:
# self._screen = _screen
# self._show()
self.mousePoint = QPoint(event.globalPos().x(), event.globalPos().y())
if self.action is None:
self.action = ACTION_SELECT
if not self.mousePressed:
point = QPoint(event.x(), event.y())
self.detectMousePosition(point)
self.setCursorStyle()
self.redraw()
else:
self.endX, self.endY = event.x(), event.y()
# if self.mousePosition != OUTSIDE_AREA:
# self.action = ACTION_MOVE_SELECTED
if self.action == ACTION_SELECT:
self.selectedArea.setBottomRight(QPoint(event.x(), event.y()))
self.redraw()
elif self.action == ACTION_MOVE_SELECTED:
self.selectedArea = QRect(self.selectedAreaRaw)
if self.mousePosition == MousePosition.INSIDE_AREA:
moveToX = event.x() - self.startX + self.selectedArea.left(
)
moveToY = event.y() - self.startY + self.selectedArea.top()
if 0 <= moveToX <= self.screenPixel.width(
) - 1 - self.selectedArea.width():
self.selectedArea.moveLeft(moveToX)
if 0 <= moveToY <= self.screenPixel.height(
) - 1 - self.selectedArea.height():
self.selectedArea.moveTop(moveToY)
self.selectedArea = self.selectedArea.normalized()
self.selectedAreaRaw = QRect(self.selectedArea)
self.startX, self.startY = event.x(), event.y()
self.redraw()
elif self.mousePosition == MousePosition.ON_THE_LEFT_SIDE:
moveToX = event.x() - self.startX + self.selectedArea.left(
)
if moveToX <= self.selectedArea.right():
self.selectedArea.setLeft(moveToX)
self.selectedArea = self.selectedArea.normalized()
self.redraw()
elif self.mousePosition == MousePosition.ON_THE_RIGHT_SIDE:
moveToX = event.x(
) - self.startX + self.selectedArea.right()
self.selectedArea.setRight(moveToX)
self.selectedArea = self.selectedArea.normalized()
self.redraw()
elif self.mousePosition == MousePosition.ON_THE_UP_SIDE:
moveToY = event.y() - self.startY + self.selectedArea.top()
self.selectedArea.setTop(moveToY)
self.selectedArea = self.selectedArea.normalized()
self.redraw()
elif self.mousePosition == MousePosition.ON_THE_DOWN_SIDE:
moveToY = event.y(
) - self.startY + self.selectedArea.bottom()
self.selectedArea.setBottom(moveToY)
self.selectedArea = self.selectedArea.normalized()
self.redraw()
elif self.mousePosition == MousePosition.ON_THE_TOP_LEFT_CORNER:
moveToX = event.x() - self.startX + self.selectedArea.left(
)
moveToY = event.y() - self.startY + self.selectedArea.top()
self.selectedArea.setTopLeft(QPoint(moveToX, moveToY))
self.selectedArea = self.selectedArea.normalized()
self.redraw()
elif self.mousePosition == MousePosition.ON_THE_BOTTOM_RIGHT_CORNER:
moveToX = event.x(
) - self.startX + self.selectedArea.right()
moveToY = event.y(
) - self.startY + self.selectedArea.bottom()
self.selectedArea.setBottomRight(QPoint(moveToX, moveToY))
self.selectedArea = self.selectedArea.normalized()
self.redraw()
elif self.mousePosition == MousePosition.ON_THE_TOP_RIGHT_CORNER:
moveToX = event.x(
) - self.startX + self.selectedArea.right()
moveToY = event.y() - self.startY + self.selectedArea.top()
self.selectedArea.setTopRight(QPoint(moveToX, moveToY))
self.selectedArea = self.selectedArea.normalized()
self.redraw()
elif self.mousePosition == MousePosition.ON_THE_BOTTOM_LEFT_CORNER:
moveToX = event.x() - self.startX + self.selectedArea.left(
)
moveToY = event.y(
) - self.startY + self.selectedArea.bottom()
self.selectedArea.setBottomLeft(QPoint(moveToX, moveToY))
self.redraw()
else:
pass
elif self.action == ACTION_RECT:
self.drawRect(self.startX, self.startY, event.x(), event.y(),
False)
self.redraw()
pass
elif self.action == ACTION_ELLIPSE:
self.drawEllipse(self.startX, self.startY, event.x(),
event.y(), False)
self.redraw()
elif self.action == ACTION_ARROW:
self.drawArrow(self.startX, self.startY, event.x(), event.y(),
False)
self.redraw()
elif self.action == ACTION_LINE:
self.drawLine(self.startX, self.startY, event.x(), event.y(),
False)
self.redraw()
elif self.action == ACTION_FREEPEN:
y1, y2 = event.x(), event.y()
rect = self.selectedArea.normalized()
if y1 <= rect.left():
y1 = rect.left()
elif y1 >= rect.right():
y1 = rect.right()
if y2 <= rect.top():
y2 = rect.top()
elif y2 >= rect.bottom():
y2 = rect.bottom()
self.pointPath.lineTo(y1, y2)
self.drawFreeLine(self.pointPath, False)
self.redraw()
def mouseReleaseEvent(self, event):
"""
:type event: QMouseEvent
:param event:
:return:
"""
if event.button() != Qt.LeftButton:
return
if self.mousePressed:
self.mousePressed = False
self.endX, self.endY = event.x(), event.y()
if self.action == ACTION_SELECT:
self.selectedArea.setBottomRight(QPoint(event.x(), event.y()))
self.selectedAreaRaw = QRect(self.selectedArea)
self.action = ACTION_MOVE_SELECTED
self.redraw()
elif self.action == ACTION_MOVE_SELECTED:
self.selectedAreaRaw = QRect(self.selectedArea)
self.redraw()
# self.action = None
elif self.action == ACTION_RECT:
self.drawRect(self.startX, self.startY, event.x(), event.y(),
True)
self.redraw()
elif self.action == ACTION_ELLIPSE:
self.drawEllipse(self.startX, self.startY, event.x(),
event.y(), True)
self.redraw()
elif self.action == ACTION_ARROW:
self.drawArrow(self.startX, self.startY, event.x(), event.y(),
True)
self.redraw()
elif self.action == ACTION_LINE:
self.drawLine(self.startX, self.startY, event.x(), event.y(),
True)
self.redraw()
elif self.action == ACTION_FREEPEN:
self.drawFreeLine(self.pointPath, True)
self.redraw()
def detectMousePosition(self, point):
"""
:type point: QPoint
:param point: the mouse position you want to check
:return:
"""
if self.selectedArea == QRect():
self.mousePosition = MousePosition.OUTSIDE_AREA
return
if self.selectedArea.left() - ERRORRANGE <= point.x(
) <= self.selectedArea.left() and (self.selectedArea.top() - ERRORRANGE
<= point.y() <=
self.selectedArea.top()):
self.mousePosition = MousePosition.ON_THE_TOP_LEFT_CORNER
elif self.selectedArea.right() <= point.x() <= self.selectedArea.right(
) + ERRORRANGE and (self.selectedArea.top() - ERRORRANGE <= point.y()
<= self.selectedArea.top()):
self.mousePosition = MousePosition.ON_THE_TOP_RIGHT_CORNER
elif self.selectedArea.left() - ERRORRANGE <= point.x(
) <= self.selectedArea.left() and (
self.selectedArea.bottom() <= point.y() <=
self.selectedArea.bottom() + ERRORRANGE):
self.mousePosition = MousePosition.ON_THE_BOTTOM_LEFT_CORNER
elif self.selectedArea.right() <= point.x() <= self.selectedArea.right(
) + ERRORRANGE and (self.selectedArea.bottom() <= point.y() <=
self.selectedArea.bottom() + ERRORRANGE):
self.mousePosition = MousePosition.ON_THE_BOTTOM_RIGHT_CORNER
elif -ERRORRANGE <= point.x() - self.selectedArea.left() <= 0 and (
self.selectedArea.topLeft().y() < point.y() <
self.selectedArea.bottomLeft().y()):
self.mousePosition = MousePosition.ON_THE_LEFT_SIDE
elif 0 <= point.x() - self.selectedArea.right() <= ERRORRANGE and (
self.selectedArea.topRight().y() < point.y() <
self.selectedArea.bottomRight().y()):
self.mousePosition = MousePosition.ON_THE_RIGHT_SIDE
elif -ERRORRANGE <= point.y() - self.selectedArea.top() <= 0 and (
self.selectedArea.topLeft().x() < point.x() <
self.selectedArea.topRight().x()):
self.mousePosition = MousePosition.ON_THE_UP_SIDE
elif 0 <= point.y() - self.selectedArea.bottom() <= ERRORRANGE and (
self.selectedArea.bottomLeft().x() < point.x() <
self.selectedArea.bottomRight().x()):
self.mousePosition = MousePosition.ON_THE_DOWN_SIDE
elif not self.selectedArea.contains(point):
self.mousePosition = MousePosition.OUTSIDE_AREA
else:
self.mousePosition = MousePosition.INSIDE_AREA
def setCursorStyle(self):
if self.action in DRAW_ACTION:
self.setCursor(Qt.CrossCursor)
return
if self.mousePosition == MousePosition.ON_THE_LEFT_SIDE or \
self.mousePosition == MousePosition.ON_THE_RIGHT_SIDE:
self.setCursor(Qt.SizeHorCursor)
elif self.mousePosition == MousePosition.ON_THE_UP_SIDE or \
self.mousePosition == MousePosition.ON_THE_DOWN_SIDE:
self.setCursor(Qt.SizeVerCursor)
elif self.mousePosition == MousePosition.ON_THE_TOP_LEFT_CORNER or \
self.mousePosition == MousePosition.ON_THE_BOTTOM_RIGHT_CORNER:
self.setCursor(Qt.SizeFDiagCursor)
elif self.mousePosition == MousePosition.ON_THE_TOP_RIGHT_CORNER or \
self.mousePosition == MousePosition.ON_THE_BOTTOM_LEFT_CORNER:
self.setCursor(Qt.SizeBDiagCursor)
elif self.mousePosition == MousePosition.OUTSIDE_AREA:
self.setCursor(Qt.ArrowCursor)
elif self.mousePosition == MousePosition.INSIDE_AREA:
self.setCursor(Qt.OpenHandCursor)
else:
self.setCursor(Qt.ArrowCursor)
pass
def drawMagnifier(self):
# First, calculate the magnifier position due to the mouse position
watchAreaWidth = 16
watchAreaHeight = 16
watchAreaPixmap = QPixmap()
cursor_pos = self.mousePoint
watchArea = QRect(
QPoint(cursor_pos.x() - watchAreaWidth / 2,
cursor_pos.y() - watchAreaHeight / 2),
QPoint(cursor_pos.x() + watchAreaWidth / 2,
cursor_pos.y() + watchAreaHeight / 2))
if watchArea.left() < 0:
watchArea.moveLeft(0)
watchArea.moveRight(watchAreaWidth)
if self.mousePoint.x() + watchAreaWidth / 2 >= self.screenPixel.width(
):
watchArea.moveRight(self.screenPixel.width() - 1)
watchArea.moveLeft(watchArea.right() - watchAreaWidth)
if self.mousePoint.y() - watchAreaHeight / 2 < 0:
watchArea.moveTop(0)
watchArea.moveBottom(watchAreaHeight)
if self.mousePoint.y(
) + watchAreaHeight / 2 >= self.screenPixel.height():
watchArea.moveBottom(self.screenPixel.height() - 1)
watchArea.moveTop(watchArea.bottom() - watchAreaHeight)
# tricks to solve the hidpi impact on QCursor.pos()
watchArea.setTopLeft(
QPoint(watchArea.topLeft().x() * self.scale,
watchArea.topLeft().y() * self.scale))
watchArea.setBottomRight(
QPoint(watchArea.bottomRight().x() * self.scale,
watchArea.bottomRight().y() * self.scale))
watchAreaPixmap = self.screenPixel.copy(watchArea)
# second, calculate the magnifier area
magnifierAreaWidth = watchAreaWidth * 10
magnifierAreaHeight = watchAreaHeight * 10
fontAreaHeight = 40
cursorSize = 24
magnifierArea = QRectF(
QPoint(QCursor.pos().x() + cursorSize,
QCursor.pos().y() + cursorSize),
QPoint(QCursor.pos().x() + cursorSize + magnifierAreaWidth,
QCursor.pos().y() + cursorSize + magnifierAreaHeight))
if magnifierArea.right() >= self.screenPixel.width():
magnifierArea.moveLeft(QCursor.pos().x() - magnifierAreaWidth -
cursorSize / 2)
if magnifierArea.bottom() + fontAreaHeight >= self.screenPixel.height(
):
magnifierArea.moveTop(QCursor.pos().y() - magnifierAreaHeight -
cursorSize / 2 - fontAreaHeight)
# third, draw the watch area to magnifier area
watchAreaScaled = watchAreaPixmap.scaled(
QSize(magnifierAreaWidth * self.scale,
magnifierAreaHeight * self.scale))
magnifierPixmap = self.graphicsScene.addPixmap(watchAreaScaled)
magnifierPixmap.setOffset(magnifierArea.topLeft())
# then draw lines and text
self.graphicsScene.addRect(QRectF(magnifierArea),
QPen(QColor(255, 255, 255), 2))
self.graphicsScene.addLine(
QLineF(QPointF(magnifierArea.center().x(), magnifierArea.top()),
QPointF(magnifierArea.center().x(),
magnifierArea.bottom())),
QPen(QColor(0, 255, 255), 2))
self.graphicsScene.addLine(
QLineF(QPointF(magnifierArea.left(),
magnifierArea.center().y()),
QPointF(magnifierArea.right(),
magnifierArea.center().y())),
QPen(QColor(0, 255, 255), 2))
# get the rgb of mouse point
pointRgb = QColor(self.screenPixel.toImage().pixel(self.mousePoint))
# draw information
self.graphicsScene.addRect(
QRectF(
magnifierArea.bottomLeft(),
magnifierArea.bottomRight() + QPoint(0, fontAreaHeight + 30)),
QPen(Qt.black), QBrush(Qt.black))
rgbInfo = self.graphicsScene.addSimpleText(
' Rgb: ({0}, {1}, {2})'.format(pointRgb.red(), pointRgb.green(),
pointRgb.blue()))
rgbInfo.setPos(magnifierArea.bottomLeft() + QPoint(0, 5))
rgbInfo.setPen(QPen(QColor(255, 255, 255), 2))
rect = self.selectedArea.normalized()
sizeInfo = self.graphicsScene.addSimpleText(' Size: {0} x {1}'.format(
rect.width() * self.scale,
rect.height() * self.scale))
sizeInfo.setPos(magnifierArea.bottomLeft() + QPoint(0, 15) +
QPoint(0, fontAreaHeight / 2))
sizeInfo.setPen(QPen(QColor(255, 255, 255), 2))
def get_scale(self):
# tricks to solve the hidpi impact on QCursor.pos()
# screen = QGuiApplication.screenAt(QCursor.pos())
# scale = self.screenPixel.width() // screen.geometry().width()
screen = QApplication.primaryScreen().virtualGeometry()
scale = self.screenPixel.width() // screen.width()
return scale
def saveScreenshot(self,
clipboard=False,
fileName='screenshot.png',
picType='png'):
fullWindow = QRect(0, 0, self.width() - 1, self.height() - 1)
selected = QRect(self.selectedArea)
if selected.left() < 0:
selected.setLeft(0)
if selected.right() >= self.width():
selected.setRight(self.width() - 1)
if selected.top() < 0:
selected.setTop(0)
if selected.bottom() >= self.height():
selected.setBottom(self.height() - 1)
source = (fullWindow & selected)
source.setTopLeft(
QPoint(source.topLeft().x() * self.scale,
source.topLeft().y() * self.scale))
source.setBottomRight(
QPoint(source.bottomRight().x() * self.scale,
source.bottomRight().y() * self.scale))
image = self.screenPixel.copy(source)
image = self.grab().copy(source)
image = image.toImage()
# if clipboard:
# QApplication.clipboard().setImage(image, QClipboard.Mode.Clipboard)
# else:
# image.save(fileName)
self.target_img = image
self.screen_shot_grabed.emit(QImage(image))
def redraw(self):
self.graphicsScene.clear()
# draw screenshot
self.graphicsScene.addPixmap(self.screenPixel)
# prepare for drawing selected area
rect = QRectF(self.selectedArea)
rect = rect.normalized()
topLeftPoint = rect.topLeft()
topRightPoint = rect.topRight()
bottomLeftPoint = rect.bottomLeft()
bottomRightPoint = rect.bottomRight()
topMiddlePoint = (topLeftPoint + topRightPoint) / 2
leftMiddlePoint = (topLeftPoint + bottomLeftPoint) / 2
bottomMiddlePoint = (bottomLeftPoint + bottomRightPoint) / 2
rightMiddlePoint = (topRightPoint + bottomRightPoint) / 2
# draw the picture mask
mask = QColor(0, 0, 0, 155)
if self.selectedArea == QRect():
self.graphicsScene.addRect(0, 0, self.screenPixel.width(),
self.screenPixel.height(),
QPen(Qt.NoPen), mask)
else:
self.graphicsScene.addRect(0, 0, self.screenPixel.width(),
topRightPoint.y(), QPen(Qt.NoPen), mask)
self.graphicsScene.addRect(0, topLeftPoint.y(), topLeftPoint.x(),
rect.height(), QPen(Qt.NoPen), mask)
self.graphicsScene.addRect(
topRightPoint.x(), topRightPoint.y(),
self.screenPixel.width() - topRightPoint.x(), rect.height(),
QPen(Qt.NoPen), mask)
self.graphicsScene.addRect(
0, bottomLeftPoint.y(), self.screenPixel.width(),
self.screenPixel.height() - bottomLeftPoint.y(),
QPen(Qt.NoPen), mask)
# draw the toolBar
if self.action != ACTION_SELECT:
spacing = 5
# show the toolbar first, then move it to the correct position
# because the width of it may be wrong if this is the first time it shows
self.tooBar.show()
dest = QPointF(rect.bottomRight() -
QPointF(self.tooBar.width(), 0) -
QPointF(spacing, -spacing))
if dest.x() < spacing:
dest.setX(spacing)
pen_set_bar_height = self.penSetBar.height(
) if self.penSetBar is not None else 0
if dest.y() + self.tooBar.height(
) + pen_set_bar_height >= self.height():
if rect.top() - self.tooBar.height(
) - pen_set_bar_height < spacing:
dest.setY(rect.top() + spacing)
else:
dest.setY(rect.top() - self.tooBar.height() -
pen_set_bar_height - spacing)
self.tooBar.move(self.mapToGlobal(dest.toPoint()))
if self.penSetBar is not None:
self.penSetBar.show()
_pen_point = QPoint(dest.toPoint() +
QPoint(0,
self.tooBar.height() + spacing))
self.penSetBar.move(self.mapToGlobal(_pen_point))
if self.action == ACTION_TEXT:
self.penSetBar.showFontWidget()
else:
self.penSetBar.showPenWidget()
else:
self.tooBar.hide()
if self.penSetBar is not None:
self.penSetBar.hide()
# draw the list
for step in self.drawListResult:
self.drawOneStep(step)
if self.drawListProcess is not None:
self.drawOneStep(self.drawListProcess)
if self.action != ACTION_TEXT:
self.drawListProcess = None
# if self.selectedArea != QRect():
# self.itemsToRemove = []
# # draw the selected rectangle
# pen = QPen(QColor(0, 255, 255), 2)
# self.itemsToRemove.append(self.graphicsScene.addRect(rect, pen))
# # draw the drag point
# radius = QPoint(3, 3)
# brush = QBrush(QColor(0, 255, 255))
# self.itemsToRemove.append(
# self.graphicsScene.addEllipse(QRectF(topLeftPoint - radius, topLeftPoint + radius), pen, brush))
# self.itemsToRemove.append(
# self.graphicsScene.addEllipse(QRectF(topMiddlePoint - radius, topMiddlePoint + radius), pen, brush))
# self.itemsToRemove.append(
# self.graphicsScene.addEllipse(QRectF(topRightPoint - radius, topRightPoint + radius), pen, brush))
# self.itemsToRemove.append(
# self.graphicsScene.addEllipse(QRectF(leftMiddlePoint - radius, leftMiddlePoint + radius), pen, brush))
# self.itemsToRemove.append(
# self.graphicsScene.addEllipse(QRectF(rightMiddlePoint - radius, rightMiddlePoint + radius), pen, brush))
# self.itemsToRemove.append(
# self.graphicsScene.addEllipse(QRectF(bottomLeftPoint - radius, bottomLeftPoint + radius), pen, brush))
# self.itemsToRemove.append(
# self.graphicsScene.addEllipse(QRectF(bottomMiddlePoint - radius, bottomMiddlePoint + radius), pen, brush))
# self.itemsToRemove.append(
# self.graphicsScene.addEllipse(QRectF(bottomRightPoint - radius, bottomRightPoint + radius), pen, brush))
# draw the textedit
if self.textPosition is not None:
textSpacing = 50
position = QPoint()
if self.textPosition.x() + self.textInput.width(
) >= self.screenPixel.width():
position.setX(self.textPosition.x() - self.textInput.width())
else:
position.setX(self.textPosition.x())
if self.textRect is not None:
if self.textPosition.y() + self.textInput.height(
) + self.textRect.height() >= self.screenPixel.height():
position.setY(self.textPosition.y() -
self.textInput.height() -
self.textRect.height())
else:
position.setY(self.textPosition.y() +
self.textRect.height())
else:
if self.textPosition.y() + self.textInput.height(
) >= self.screenPixel.height():
position.setY(self.textPosition.y() -
self.textInput.height())
else:
position.setY(self.textPosition.y())
self.textInput.move(self.mapToGlobal(position))
self.textInput.show()
# self.textInput.getFocus()
# draw the magnifier
if self.action == ACTION_SELECT:
self.drawMagnifier()
if self.mousePressed:
self.drawSizeInfo()
if self.action == ACTION_MOVE_SELECTED:
self.drawSizeInfo()
# deal with every step in drawList
def drawOneStep(self, step):
"""
:type step: tuple
"""
if step[0] == ACTION_RECT:
self.graphicsScene.addRect(
QRectF(QPointF(step[1], step[2]), QPointF(step[3], step[4])),
step[5])
elif step[0] == ACTION_ELLIPSE:
self.graphicsScene.addEllipse(
QRectF(QPointF(step[1], step[2]), QPointF(step[3], step[4])),
step[5])
elif step[0] == ACTION_ARROW:
arrow = QPolygonF()
linex = float(step[1] - step[3])
liney = float(step[2] - step[4])
line = sqrt(pow(linex, 2) + pow(liney, 2))
# in case to divided by 0
if line == 0:
return
sinAngel = liney / line
cosAngel = linex / line
# sideLength is the length of bottom side of the body of an arrow
# arrowSize is the size of the head of an arrow, left and right
# sides' size is arrowSize, and the bottom side's size is arrowSize / 2
sideLength = step[5].width()
arrowSize = 8
bottomSize = arrowSize / 2
tmpPoint = QPointF(step[3] + arrowSize * sideLength * cosAngel,
step[4] + arrowSize * sideLength * sinAngel)
point1 = QPointF(step[1] + sideLength * sinAngel,
step[2] - sideLength * cosAngel)
point2 = QPointF(step[1] - sideLength * sinAngel,
step[2] + sideLength * cosAngel)
point3 = QPointF(tmpPoint.x() - sideLength * sinAngel,
tmpPoint.y() + sideLength * cosAngel)
point4 = QPointF(tmpPoint.x() - bottomSize * sideLength * sinAngel,
tmpPoint.y() + bottomSize * sideLength * cosAngel)
point5 = QPointF(step[3], step[4])
point6 = QPointF(tmpPoint.x() + bottomSize * sideLength * sinAngel,
tmpPoint.y() - bottomSize * sideLength * cosAngel)
point7 = QPointF(tmpPoint.x() + sideLength * sinAngel,
tmpPoint.y() - sideLength * cosAngel)
arrow.append(point1)
arrow.append(point2)
arrow.append(point3)
arrow.append(point4)
arrow.append(point5)
arrow.append(point6)
arrow.append(point7)
arrow.append(point1)
self.graphicsScene.addPolygon(arrow, step[5], step[6])
elif step[0] == ACTION_LINE:
self.graphicsScene.addLine(
QLineF(QPointF(step[1], step[2]), QPointF(step[3], step[4])),
step[5])
elif step[0] == ACTION_FREEPEN:
self.graphicsScene.addPath(step[1], step[2])
elif step[0] == ACTION_TEXT:
textAdd = self.graphicsScene.addSimpleText(step[1], step[2])
textAdd.setPos(step[3])
textAdd.setBrush(QBrush(step[4]))
self.textRect = textAdd.boundingRect()
# draw the size information on the top left corner
def drawSizeInfo(self):
sizeInfoAreaWidth = 200
sizeInfoAreaHeight = 30
spacing = 5
rect = self.selectedArea.normalized()
sizeInfoArea = QRect(rect.left(),
rect.top() - spacing - sizeInfoAreaHeight,
sizeInfoAreaWidth, sizeInfoAreaHeight)
if sizeInfoArea.top() < 0:
sizeInfoArea.moveTopLeft(rect.topLeft() + QPoint(spacing, spacing))
if sizeInfoArea.right() >= self.screenPixel.width():
sizeInfoArea.moveTopLeft(rect.topLeft() -
QPoint(spacing, spacing) -
QPoint(sizeInfoAreaWidth, 0))
if sizeInfoArea.left() < spacing:
sizeInfoArea.moveLeft(spacing)
if sizeInfoArea.top() < spacing:
sizeInfoArea.moveTop(spacing)
self.itemsToRemove.append(
self.graphicsScene.addRect(QRectF(sizeInfoArea), QPen(Qt.white),
QBrush(Qt.black)))
sizeInfo = self.graphicsScene.addSimpleText(' {0} x {1}'.format(
rect.width() * self.scale,
rect.height() * self.scale))
sizeInfo.setPos(sizeInfoArea.topLeft() + QPoint(0, 2))
sizeInfo.setPen(QPen(QColor(255, 255, 255), 2))
self.itemsToRemove.append(sizeInfo)
def drawRect(self, x1, x2, y1, y2, result):
rect = self.selectedArea.normalized()
tmpRect = QRect(QPoint(x1, x2), QPoint(y1, y2)).normalized()
resultRect = rect & tmpRect
tmp = [
ACTION_RECT,
resultRect.topLeft().x(),
resultRect.topLeft().y(),
resultRect.bottomRight().x(),
resultRect.bottomRight().y(),
QPen(QColor(self.penColorNow), int(self.penSizeNow))
]
if result:
self.drawListResult.append(tmp)
else:
self.drawListProcess = tmp
def drawEllipse(self, x1, x2, y1, y2, result):
rect = self.selectedArea.normalized()
tmpRect = QRect(QPoint(x1, x2), QPoint(y1, y2)).normalized()
resultRect = rect & tmpRect
tmp = [
ACTION_ELLIPSE,
resultRect.topLeft().x(),
resultRect.topLeft().y(),
resultRect.bottomRight().x(),
resultRect.bottomRight().y(),
QPen(QColor(self.penColorNow), int(self.penSizeNow))
]
if result:
self.drawListResult.append(tmp)
else:
self.drawListProcess = tmp
def drawArrow(self, x1, x2, y1, y2, result):
rect = self.selectedArea.normalized()
if y1 <= rect.left():
y1 = rect.left()
elif y1 >= rect.right():
y1 = rect.right()
if y2 <= rect.top():
y2 = rect.top()
elif y2 >= rect.bottom():
y2 = rect.bottom()
tmp = [
ACTION_ARROW, x1, x2, y1, y2,
QPen(QColor(self.penColorNow), int(self.penSizeNow)),
QBrush(QColor(self.penColorNow))
]
if result:
self.drawListResult.append(tmp)
else:
self.drawListProcess = tmp
def drawLine(self, x1, x2, y1, y2, result):
rect = self.selectedArea.normalized()
if y1 <= rect.left():
y1 = rect.left()
elif y1 >= rect.right():
y1 = rect.right()
if y2 <= rect.top():
y2 = rect.top()
elif y2 >= rect.bottom():
y2 = rect.bottom()
tmp = [
ACTION_LINE, x1, x2, y1, y2,
QPen(QColor(self.penColorNow), int(self.penSizeNow))
]
if result:
self.drawListResult.append(tmp)
else:
self.drawListProcess = tmp
def drawFreeLine(self, pointPath, result):
tmp = [
ACTION_FREEPEN,
QPainterPath(pointPath),
QPen(QColor(self.penColorNow), int(self.penSizeNow))
]
if result:
self.drawListResult.append(tmp)
else:
self.drawListProcess = tmp
def textChange(self):
if self.textPosition is None:
return
self.text = self.textInput.getText()
self.drawListProcess = [
ACTION_TEXT,
str(self.text),
QFont(self.fontNow),
QPoint(self.textPosition),
QColor(self.penColorNow)
]
self.redraw()
def undoOperation(self):
if len(self.drawListResult) == 0:
self.action = ACTION_SELECT
self.selectedArea = QRect()
self.selectedAreaRaw = QRect()
self.tooBar.hide()
if self.penSetBar is not None:
self.penSetBar.hide()
else:
self.drawListResult.pop()
self.redraw()
def saveOperation(self):
filename = QFileDialog.getSaveFileName(self, 'Save file',
'./screenshot.png',
'*.png;;*.jpg')
if len(filename[0]) == 0:
return
else:
self.saveScreenshot(False, filename[0], filename[1][2:])
self.close()
def close(self):
self.widget_closed.emit()
super(Screenshot, self).close()
self.tooBar.close()
if self.penSetBar is not None:
self.penSetBar.close()
def saveToClipboard(self):
QApplication.clipboard().setText('Test in save function')
self.saveScreenshot(True)
self.close()
# slots
def changeAction(self, nextAction):
QApplication.clipboard().setText('Test in changeAction function')
if nextAction == ACTION_UNDO:
self.undoOperation()
elif nextAction == ACTION_SAVE:
self.saveOperation()
elif nextAction == ACTION_CANCEL:
self.close()
elif nextAction == ACTION_SURE:
self.saveToClipboard()
else:
self.action = nextAction
self.setFocus()
def changePenSize(self, nextPenSize):
self.penSizeNow = nextPenSize
def changePenColor(self, nextPenColor):
self.penColorNow = nextPenColor
def cancelInput(self):
self.drawListProcess = None
self.textPosition = None
self.textRect = None
self.textInput.hide()
self.textInput.clearText()
self.redraw()
def okInput(self):
self.text = self.textInput.getText()
self.drawListResult.append([
ACTION_TEXT,
str(self.text),
QFont(self.fontNow),
QPoint(self.textPosition),
QColor(self.penColorNow)
])
self.textPosition = None
self.textRect = None
self.textInput.hide()
self.textInput.clearText()
self.redraw()
def changeFont(self, font):
self.fontNow = font
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
painter.setRenderHint(painter.Antialiasing)
font = painter.font()
font.setBold(True)
painter.setFont(font)
x = self.rect().x()
y = self.rect().y()
w = self.rect().width() - 1
h = self.rect().height() - 1
_rect = 5
if self.rollout_style == AccordionStyle.ROUNDED:
border_color = self.palette().color(QPalette.Light)
header_color = QColor(self._theme.background_color).lighter(90)
background_color = QColor(self._theme.background_color).lighter(135)
painter.save()
# pen = QPen(border_color)
# pen.setWidthF(0.1)
painter.setPen(Qt.NoPen)
painter.setBrush(QBrush(background_color))
painter.drawRoundedRect(x + 1, y + 1, w - 1, h - 1, _rect, _rect)
# pen.setColor(self.palette().color(QPalette.Shadow))
# painter.setPen(pen)
# painter.drawRoundedRect(x, y, w - 1, h - 1, _rect, _rect)
path = QPainterPath()
path.setFillRule(Qt.WindingFill)
path.addRoundedRect(x + 1, y + 1, w - 1, 20, _rect, _rect)
if not self.is_collapsed():
path.addRect(x + 1, y + 16, w - 1, 5)
painter.setBrush(QBrush(header_color))
painter.drawPath(path.simplified())
painter.restore()
painter.drawText(x + 33 if not self._icon else 40, y + 3, w, 16, Qt.AlignLeft | Qt.AlignTop, self.title())
self._draw_triangle(painter, x, y)
self._draw_icon(painter, x + 22, y + 3)
elif self.rollout_style == AccordionStyle.SQUARE:
painter.drawText(x + 33 if not self._icon else 40, y + 3, w, 16, Qt.AlignLeft | Qt.AlignTop, self.title())
self._draw_triangle(painter, x, y)
self._draw_icon(painter, x + 22, y + 3)
pen = QPen(self.palette().color(QPalette.Light))
pen.setWidthF(0.15)
painter.setPen(pen)
painter.drawRect(x + 1, y + 1, w - 1, h - 1)
pen.setColor(self.palette().color(QPalette.Shadow))
painter.setPen(pen)
elif self.rollout_style == AccordionStyle.MAYA:
painter.drawText(x + 33 if not self._icon else 40, y + 3, w, 16, Qt.AlignLeft | Qt.AlignTop, self.title())
painter.setRenderHint(QPainter.Antialiasing, False)
self._draw_triangle(painter, x, y)
self._draw_icon(painter, x + 22, y + 3)
header_height = 20
header_rect = QRect(x + 1, y + 1, w - 1, header_height)
header_rect_shadow = QRect(x - 1, y - 1, w + 1, header_height + 2)
pen = QPen(self.palette().color(QPalette.Light))
pen.setWidthF(0.4)
# painter.setPen(pen)
painter.setPen(Qt.NoPen)
painter.drawRect(header_rect)
painter.fillRect(header_rect, QColor(255, 255, 255, 18))
pen.setColor(self.palette().color(QPalette.Dark))
painter.setPen(pen)
painter.drawRect(header_rect_shadow)
if not self.is_collapsed():
# pen = QPen(self.palette().color(QPalette.Dark))
# pen.setWidthF(0.8)
# painter.setPen(pen)
offset = header_height + 3
body_rect = QRect(x, y + offset, w, h - offset)
# body_rect_shadow = QRect(x + 1, y + offset, w + 1, h - offset + 1)
painter.drawRect(body_rect)
# pen.setColor(self.palette().color(QPalette.Light))
# pen.setWidth(0.4)
# painter.setPen(pen)
# painter.drawRect(body_rect_shadow)
elif self.rollout_style == AccordionStyle.BOXED:
if self.is_collapsed():
a_rect = QRect(x + 1, y + 9, w - 1, 4)
b_rect = QRect(x, y + 8, w - 1, 4)
text = '+'
else:
a_rect = QRect(x + 1, y + 9, w - 1, h - 9)
b_rect = QRect(x, y + 8, w - 1, h - 9)
text = '-'
pen = QPen(self.palette().color(QPalette.Light))
pen = QPen(Qt.red)
pen.setWidthF(0.6)
painter.setPen(pen)
painter.drawRect(a_rect)
# pen.setColor(self.palette().color(QPalette.Shadow))
# painter.setPen(pen)
painter.drawRect(b_rect)
painter.setRenderHint(painter.Antialiasing, False)
painter.setBrush(self.palette().color(QPalette.Window).darker(120))
painter.drawRect(x + 10, y + 1, w - 20, 16)
painter.drawText(x + 16, y + 1, w - 32, 16, Qt.AlignLeft | Qt.AlignVCenter, text)
painter.drawText(x + 10, y + 1, w - 20, 16, Qt.AlignCenter, self.title())
if self.drag_drop_mode:
rect = self.get_drag_drop_rect()
_layout = rect.left()
_rect = rect.right()
center_y = rect.center().y()
for y in (center_y - 3, center_y, center_y + 3):
painter.drawLine(_layout, y, _rect, y)
painter.end()
def paintEvent(base_button, event):
painter = QStylePainter(base_button)
painter.setRenderHint(QPainter.Antialiasing)
option = QStyleOption()
option.initFrom(base_button)
x = option.rect.x()
y = option.rect.y()
height = option.rect.height() - 1
width = option.rect.width() - 1
radius = base_button._radius
gradient = BaseButtonStyle._gradient[NORMAL]
offset = 0
icon_offset = 3 # TODO: maybe we want set this as a property of the base button
if base_button.isCheckable():
if base_button.isChecked():
gradient = BaseButtonStyle._gradient[DOWN]
offset = 1
else:
if base_button.isDown():
gradient = BaseButtonStyle._gradient[DOWN]
offset = 1
elif not base_button.isEnabled():
gradient = BaseButtonStyle._gradient[DISABLED]
painter.setBrush(base_button._brush_border)
painter.setPen(base_button._pens_border)
painter.drawRoundedRect(QRect(x + 1, y + 1, width - 1, height - 1),
radius, radius)
painter.setPen(base_button._pens_clear)
painter.setBrush(gradient[OUTER])
painter.drawRoundedRect(QRect(x + 1, y + 1, width - 1, height - 1),
radius, radius)
painter.setBrush(gradient[INNER])
painter.drawRoundedRect(QRect(x + 2, y + 2, width - 2, height - 2),
radius - 1, radius - 1)
painter.setBrush(base_button._brush_clear)
text = base_button.text()
font = base_button.font()
text_width = base_button._font_metrics.width(text)
text_height = font.pointSize()
text_path = QPainterPath()
has_icon = base_button.icon()
if has_icon:
if base_button.text() == '' or base_button.text() is None:
icon_size = max(
min(height, width) - 2 * base_button._pad,
base_button._min_size)
painter.drawPixmap((width - icon_size) / 2,
(height - icon_size) / 2,
base_button.icon().pixmap(icon_size))
else:
icon_size = max(
min(height, width) - 2 * base_button._pad,
base_button._min_size)
painter.drawPixmap((width - icon_size - text_width) / 2,
(height - icon_size) / 2,
base_button.icon().pixmap(icon_size))
if has_icon:
text_path.addText(
(width - text_width + icon_size + icon_offset) / 2,
height - ((height - text_height) / 2) - 1 + offset, font, text)
else:
text_path.addText(
(width - text_width) / 2,
height - ((height - text_height) / 2) - 1 + offset, font, text)
glow_index = base_button._glow_index
glow_pens = base_button._glow_pens
alignment = (Qt.AlignHCenter | Qt.AlignVCenter)
if base_button.isEnabled():
painter.setPen(base_button._pens_shadow)
painter.drawPath(text_path)
painter.setPen(base_button._pens_text)
if has_icon:
painter.drawText(x + ((icon_size + icon_offset) * 0.5),
y + offset, width, height, alignment, text)
else:
painter.drawText(x, y + offset, width, height, alignment, text)
if glow_index > 0:
for index in range(3):
painter.setPen(glow_pens[glow_index][index])
painter.drawPath(text_path)
painter.setPen(glow_pens[glow_index][3])
if has_icon:
painter.drawText(x + ((icon_size + icon_offset) * 0.5),
y + offset, width, height, alignment,
text)
else:
painter.drawText(x, y + offset, width, height, alignment,
text)
else:
painter.setPen(base_button._pens_shadow_disabled)
painter.drawPath(text_path)
painter.setPen(base_button._pens_text_disabled)
if has_icon:
painter.drawText(x + ((icon_size + icon_offset) * 0.5),
y + offset, width, height, alignment, text)
else:
painter.drawText(x, y + offset, width, height, alignment, text)
def create_svg_path(orders, verbose=False):
path = QPainterPath()
for k, order in enumerate(orders):
if order[0] == 'M' or order[0] == 'm':
if verbose:
print(k, 'MOVE TO', order[1])
move_to(path, *order)
if verbose:
print(path.elementAt(path.elementCount() - 1).type)
elif order[0] == 'C' or order[0] == 'c':
if verbose:
print(k, 'CUBIC TO', order[1])
cubic_to(path, *order)
if verbose:
print(path.elementAt(path.elementCount() - 1).type)
elif order[0] == 'S' or order[0] == 's':
if verbose:
print(k, 'SMOOTH CUBIC TO', order[1])
smooth_cubic_to(path, *order)
if verbose:
print(path.elementAt(path.elementCount() - 1).type)
elif order[0] == 'Q' or order[0] == 'q':
if verbose:
print(k, 'QUAD TO', order[1])
quad_to(path, *order)
if verbose:
print(path.elementAt(path.elementCount() - 1).type)
elif order[0] == 'T' or order[0] == 't':
if verbose:
print(k, 'SMOOTH QUAD TO', order[1])
smooth_quad_to(path, *order)
if verbose:
print(path.elementAt(path.elementCount() - 1).type)
elif order[0] == 'H' or order[0] == 'h':
if verbose:
print(k, 'HORIZONTAL LINE TO', order[1])
horizontal_line_to(path, *order)
if verbose:
print(path.elementAt(path.elementCount() - 1).type)
elif order[0] == 'V' or order[0] == 'v':
if verbose:
print(k, 'VERTICAL LINE TO', order[1])
vertical_line_to(path, *order)
if verbose:
print(path.elementAt(path.elementCount() - 1).type)
elif order[0] == 'L' or order[0] == 'l':
if verbose:
print(k, 'LINE TO', order[1])
line_to(path, *order)
if verbose:
print(path.elementAt(path.elementCount() - 1).type)
elif order[0] == 'A' or order[0] == 'a':
if verbose:
print(k, 'ARC TO', order[1])
arc_to(path, *order)
if verbose:
print(path.elementAt(path.elementCount() - 1).type)
elif order[0] == 'z' or order[0] == 'Z':
if verbose:
print(k, 'close sub path')
path.closeSubpath()
if verbose:
print(path.elementAt(path.elementCount() - 1).type)
elif verbose:
print(k, order)
if verbose:
print('------------end-------------')
return path
def shape(self):
path = QPainterPath()
path.addEllipse(self.boundingRect())
return path
def paintEvent(base_button, event):
painter = QStylePainter(base_button)
painter.setRenderHint(QPainter.Antialiasing)
option = QStyleOption()
option.initFrom(base_button)
x = option.rect.x()
y = option.rect.y()
height = option.rect.height() - 1
width = option.rect.width() - 1
radius = base_button._radius
gradient = BaseButtonStyle._gradient[NORMAL]
offset = 0
if base_button.isCheckable():
if base_button.isChecked():
gradient = BaseButtonStyle._gradient[DOWN]
offset = 1
else:
if base_button.isDown():
gradient = BaseButtonStyle._gradient[DOWN]
offset = 1
elif not base_button.isEnabled():
gradient = BaseButtonStyle._gradient[DISABLED]
painter.setBrush(base_button._brush_border)
painter.setPen(base_button._pens_border)
painter.drawRoundedRect(QRect(x + 1, y + 1, width - 1, height - 1),
radius, radius)
if base_button.isCheckable():
if base_button.isChecked():
painter.setPen(base_button._pens_clear)
painter.setBrush(gradient[OUTER])
painter.drawRoundedRect(
QRect(x + 1, y + 1, width - 1, height - 1), radius, radius)
else:
painter.setPen(base_button._pens_clear)
painter.setBrush(gradient[OUTER])
painter.drawRoundedRect(
QRect(x + 2, y + 2, width - 2, height - 2), radius, radius)
else:
if base_button.isDown():
painter.setPen(base_button._pens_clear)
painter.setBrush(gradient[OUTER])
painter.drawRoundedRect(
QRect(x + 1, y + 1, width - 1, height - 1), radius, radius)
else:
painter.setPen(base_button._pens_clear)
painter.setBrush(gradient[OUTER])
painter.drawRoundedRect(
QRect(x + 2, y + 2, width - 2, height - 2), radius, radius)
painter.setBrush(gradient[INNER])
painter.drawRoundedRect(QRect(x + 3, y + 3, width - 3, height - 3),
radius - 1, radius - 1)
painter.setBrush(base_button._brush_clear)
text = base_button.text()
font = base_button.font()
text_width = base_button._font_metrics.width(text)
text_height = font.pointSize()
text_path = QPainterPath()
text_path.addText((width - text_width) / 2,
height - ((height - text_height) / 2) - 1 + offset,
font, text)
glow_index = base_button._glow_index
glow_pens = base_button._glow_pens
alignment = (Qt.AlignHCenter | Qt.AlignVCenter)
if base_button.isEnabled():
painter.setPen(base_button._pens_shadow)
painter.drawPath(text_path)
painter.setPen(base_button._pens_text)
painter.drawText(x, y + offset, width, height, alignment, text)
if glow_index > 0:
for index in range(3):
painter.setPen(glow_pens[glow_index][index])
painter.drawPath(text_path)
painter.setPen(glow_pens[glow_index][3])
painter.drawText(x, y + offset, width, height, alignment, text)
else:
painter.setPen(base_button._pens_shadow_disabled)
painter.drawPath(text_path)
painter.setPen(base_button._pens_text_disabled)
painter.drawText(x, y + offset, width, height, alignment, text)
def shape(self):
path = QPainterPath()
path.addRect(14, 14, 82, 42)
return path
