eric: comparison src/eric7/Snapshot/SnapshotFreehandGrabber.py

-:e9e7eca7efee
+:bf71ee032bb4
 Module implementing a grabber widget for a freehand snapshot region.
 """
 from PyQt6.QtCore import pyqtSignal, Qt, QRect, QPoint, QTimer, QLocale
 from PyQt6.QtGui import (
-QPixmap, QColor, QRegion, QPainter, QPalette, QPolygon, QPen, QBrush,
+QPixmap,
-QPaintEngine, QGuiApplication, QCursor
+QColor,
+QRegion,
+QPainter,
+QPalette,
+QPolygon,
+QPen,
+QBrush,
+QPaintEngine,
+QGuiApplication,
+QCursor,
 )
 from PyQt6.QtWidgets import QWidget, QToolTip
 import Globals
 def drawPolygon(painter, polygon, outline, fill=None):
 """
 Module function to draw a polygon with the given parameters.
 @param painter reference to the painter to be used (QPainter)
 @param polygon polygon to be drawn (QPolygon)
 @param outline color of the outline (QColor)
 @param fill fill color (QColor)
 """
 clip = QRegion(polygon)
 clip -= QRegion(polygon)
-pen = QPen(outline, 1, Qt.PenStyle.SolidLine, Qt.PenCapStyle.SquareCap,
+pen = QPen(
-Qt.PenJoinStyle.BevelJoin)
+outline,
+1,
+Qt.PenStyle.SolidLine,
+Qt.PenCapStyle.SquareCap,
+Qt.PenJoinStyle.BevelJoin,
+)
 painter.save()
 painter.setClipRegion(clip)
 painter.setPen(pen)
 painter.drawPolygon(QPolygon(polygon))
 if fill and fill.isValid():
 class SnapshotFreehandGrabber(QWidget):
 """
 Class implementing a grabber widget for a freehand snapshot region.
 @signal grabbed(QPixmap) emitted after the region was grabbed
 """
 grabbed = pyqtSignal(QPixmap)
 def __init__(self):
 """
 Constructor
 """
 super().__init__(
 None,
-Qt.WindowType.X11BypassWindowManagerHint |
+Qt.WindowType.X11BypassWindowManagerHint
-Qt.WindowType.WindowStaysOnTopHint |
+| Qt.WindowType.WindowStaysOnTopHint
-Qt.WindowType.FramelessWindowHint |
+| Qt.WindowType.FramelessWindowHint
-Qt.WindowType.Tool
+| Qt.WindowType.Tool,
 )
 self.__selection = QPolygon()
 self.__mouseDown = False
 self.__newSelection = False
 self.__handleSize = 10
 self.__showHelp = True
 self.__grabbing = False
 self.__dragStartPoint = QPoint()
 self.__selectionBeforeDrag = QPolygon()
 self.__locale = QLocale()
 self.__helpTextRect = QRect()
 self.__helpText = self.tr(
 "Select a region using the mouse. To take the snapshot,"
-" press the Enter key or double click. Press Esc to quit.")
+" press the Enter key or double click. Press Esc to quit."
+)
 self.__pixmap = QPixmap()
 self.__pBefore = QPoint()
 self.setMouseTracking(True)
 QTimer.singleShot(200, self.__initialize)
 def __initialize(self):
 """
 Private slot to initialize the rest of the widget.
 """
 if Globals.isMacPlatform():
 # macOS variant
 screen = QGuiApplication.screenAt(QCursor.pos())
 geom = screen.geometry()
 self.__pixmap = screen.grabWindow(
-0, geom.x(), geom.y(), geom.width(), geom.height())
+0, geom.x(), geom.y(), geom.width(), geom.height()
+)
 else:
 # Linux variant
 # Windows variant
 screen = QGuiApplication.screens()[0]
 geom = screen.availableVirtualGeometry()
 self.__pixmap = screen.grabWindow(
-0, geom.x(), geom.y(), geom.width(), geom.height())
+0, geom.x(), geom.y(), geom.width(), geom.height()
+)
 self.resize(self.__pixmap.size())
 self.move(geom.x(), geom.y())
 self.setCursor(Qt.CursorShape.CrossCursor)
 self.show()
 self.grabMouse()
 self.grabKeyboard()
 self.activateWindow()
 def paintEvent(self, evt):
 """
 Protected method handling paint events.
 @param evt paint event (QPaintEvent)
 """
-if self.__grabbing:     # grabWindow() should just get the background
+if self.__grabbing:  # grabWindow() should just get the background
 return
 painter = QPainter(self)
 pal = QPalette(QToolTip.palette())
 font = QToolTip.font()
-handleColor = pal.color(QPalette.ColorGroup.Active,
+handleColor = pal.color(
-QPalette.ColorRole.Highlight)
+QPalette.ColorGroup.Active, QPalette.ColorRole.Highlight
+)
 handleColor.setAlpha(160)
 overlayColor = QColor(0, 0, 0, 160)
-textColor = pal.color(QPalette.ColorGroup.Active,
+textColor = pal.color(QPalette.ColorGroup.Active, QPalette.ColorRole.Text)
-QPalette.ColorRole.Text)
+textBackgroundColor = pal.color(
-textBackgroundColor = pal.color(QPalette.ColorGroup.Active,
+QPalette.ColorGroup.Active, QPalette.ColorRole.Base
-QPalette.ColorRole.Base)
+)
 painter.drawPixmap(0, 0, self.__pixmap)
 painter.setFont(font)
 pol = QPolygon(self.__selection)
 if not self.__selection.boundingRect().isNull():
 # Draw outline around selection.
 # Important: the 1px-wide outline is *also* part of the
 # captured free-region
-pen = QPen(handleColor, 1, Qt.PenStyle.SolidLine,
+pen = QPen(
-Qt.PenCapStyle.SquareCap, Qt.PenJoinStyle.BevelJoin)
+handleColor,
+1,
+Qt.PenStyle.SolidLine,
+Qt.PenCapStyle.SquareCap,
+Qt.PenJoinStyle.BevelJoin,
+)
 painter.setPen(pen)
 painter.drawPolygon(pol)
 # Draw the grey area around the selection.
 grey = QRegion(self.rect())
 grey -= QRegion(pol)
 painter.setClipRegion(grey)
 painter.setPen(Qt.PenStyle.NoPen)
 painter.setBrush(overlayColor)
 painter.drawRect(self.rect())
 painter.setClipRect(self.rect())
 drawPolygon(painter, pol, handleColor)
 if self.__showHelp:
 painter.setPen(textColor)
 painter.setBrush(textBackgroundColor)
 self.__helpTextRect = painter.boundingRect(
 self.rect().adjusted(2, 2, -2, -2),
-Qt.TextFlag.TextWordWrap, self.__helpText).translated(0, 0)
+Qt.TextFlag.TextWordWrap,
+self.__helpText,
+).translated(0, 0)
 self.__helpTextRect.adjust(-2, -2, 4, 2)
-drawPolygon(painter, self.__helpTextRect, textColor,
+drawPolygon(painter, self.__helpTextRect, textColor, textBackgroundColor)
-textBackgroundColor)
 painter.drawText(
 self.__helpTextRect.adjusted(3, 3, -3, -3),
-Qt.TextFlag.TextWordWrap, self.__helpText)
+Qt.TextFlag.TextWordWrap,
+self.__helpText,
+)
 if self.__selection.isEmpty():
 return
 # The grabbed region is everything which is covered by the drawn
 # rectangles (border included). This means that there is no 0px
 # selection, since a 0px wide rectangle will always be drawn as a line.
 boundingRect = self.__selection.boundingRect()
 txt = "{0}, {1} ({2} x {3})".format(
 self.__locale.toString(boundingRect.x()),
 self.__locale.toString(boundingRect.y()),
 self.__locale.toString(boundingRect.width()),
-self.__locale.toString(boundingRect.height())
+self.__locale.toString(boundingRect.height()),
 )
-textRect = painter.boundingRect(self.rect(),
+textRect = painter.boundingRect(self.rect(), Qt.AlignmentFlag.AlignLeft, txt)
-Qt.AlignmentFlag.AlignLeft, txt)
 boundingRect = textRect.adjusted(-4, 0, 0, 0)
 polBoundingRect = pol.boundingRect()
 if (
-(textRect.width() <
+(textRect.width() < polBoundingRect.width() - 2 * self.__handleSize)
-polBoundingRect.width() - 2 * self.__handleSize) and
+and (textRect.height() < polBoundingRect.height() - 2 * self.__handleSize)
-(textRect.height() <
+and polBoundingRect.width() > 100
-polBoundingRect.height() - 2 * self.__handleSize) and
+and polBoundingRect.height() > 100
-polBoundingRect.width() > 100 and
-polBoundingRect.height() > 100
 ):
 # center, unsuitable for small selections
 boundingRect.moveCenter(polBoundingRect.center())
 textRect.moveCenter(polBoundingRect.center())
 elif (
-polBoundingRect.y() - 3 > textRect.height() and
+polBoundingRect.y() - 3 > textRect.height()
-polBoundingRect.x() + textRect.width() < self.rect().width()
+and polBoundingRect.x() + textRect.width() < self.rect().width()
 ):
 # on top, left aligned
 boundingRect.moveBottomLeft(
-QPoint(polBoundingRect.x(), polBoundingRect.y() - 3))
+QPoint(polBoundingRect.x(), polBoundingRect.y() - 3)
+)
 textRect.moveBottomLeft(
-QPoint(polBoundingRect.x() + 2, polBoundingRect.y() - 3))
+QPoint(polBoundingRect.x() + 2, polBoundingRect.y() - 3)
+)
 elif polBoundingRect.x() - 3 > textRect.width():
 # left, top aligned
 boundingRect.moveTopRight(
-QPoint(polBoundingRect.x() - 3, polBoundingRect.y()))
+QPoint(polBoundingRect.x() - 3, polBoundingRect.y())
-textRect.moveTopRight(
+)
-QPoint(polBoundingRect.x() - 5, polBoundingRect.y()))
+textRect.moveTopRight(QPoint(polBoundingRect.x() - 5, polBoundingRect.y()))
 elif (
-(polBoundingRect.bottom() + 3 + textRect.height() <
+polBoundingRect.bottom() + 3 + textRect.height() < self.rect().bottom()
-self.rect().bottom()) and
+) and polBoundingRect.right() > textRect.width():
-polBoundingRect.right() > textRect.width()
-):
 # at bottom, right aligned
 boundingRect.moveTopRight(
-QPoint(polBoundingRect.right(), polBoundingRect.bottom() + 3))
+QPoint(polBoundingRect.right(), polBoundingRect.bottom() + 3)
+)
 textRect.moveTopRight(
-QPoint(polBoundingRect.right() - 2,
+QPoint(polBoundingRect.right() - 2, polBoundingRect.bottom() + 3)
-polBoundingRect.bottom() + 3))
+)
-elif (
+elif polBoundingRect.right() + textRect.width() + 3 < self.rect().width():
-polBoundingRect.right() + textRect.width() + 3 <
-self.rect().width()
-):
 # right, bottom aligned
 boundingRect.moveBottomLeft(
-QPoint(polBoundingRect.right() + 3, polBoundingRect.bottom()))
+QPoint(polBoundingRect.right() + 3, polBoundingRect.bottom())
+)
 textRect.moveBottomLeft(
-QPoint(polBoundingRect.right() + 5, polBoundingRect.bottom()))
+QPoint(polBoundingRect.right() + 5, polBoundingRect.bottom())
+)
 # If the above didn't catch it, you are running on a very
 # tiny screen...
 drawPolygon(painter, boundingRect, textColor, textBackgroundColor)
 painter.drawText(textRect, Qt.AlignmentFlag.AlignHCenter, txt)
 if (
-(polBoundingRect.height() > self.__handleSize * 2 and
+polBoundingRect.height() > self.__handleSize * 2
-polBoundingRect.width() > self.__handleSize * 2) or
+and polBoundingRect.width() > self.__handleSize * 2
-not self.__mouseDown
+) or not self.__mouseDown:
-):
 painter.setBrush(Qt.GlobalColor.transparent)
 painter.setClipRegion(QRegion(pol))
 painter.drawPolygon(QPolygon(self.rect()))
 def mousePressEvent(self, evt):
 """
 Protected method to handle mouse button presses.
 @param evt mouse press event (QMouseEvent)
 """
 self.__pBefore = evt.position().toPoint()
-self.__showHelp = not self.__helpTextRect.contains(
+self.__showHelp = not self.__helpTextRect.contains(evt.position().toPoint())
-evt.position().toPoint())
 if evt.button() == Qt.MouseButton.LeftButton:
 self.__mouseDown = True
 self.__dragStartPoint = evt.position().toPoint()
 self.__selectionBeforeDrag = QPolygon(self.__selection)
-if not self.__selection.containsPoint(evt.position().toPoint(),
+if not self.__selection.containsPoint(
-Qt.FillRule.WindingFill):
+evt.position().toPoint(), Qt.FillRule.WindingFill
+):
 self.__newSelection = True
 self.__selection = QPolygon()
 else:
 self.setCursor(Qt.CursorShape.ClosedHandCursor)
 elif evt.button() == Qt.MouseButton.RightButton:
 self.__newSelection = False
 self.__selection = QPolygon()
 self.setCursor(Qt.CursorShape.CrossCursor)
 self.update()
 def mouseMoveEvent(self, evt):
 """
 Protected method to handle mouse movements.
 @param evt mouse move event (QMouseEvent)
 """
-shouldShowHelp = not self.__helpTextRect.contains(
+shouldShowHelp = not self.__helpTextRect.contains(evt.position().toPoint())
-evt.position().toPoint())
 if shouldShowHelp != self.__showHelp:
 self.__showHelp = shouldShowHelp
 self.update()
 if self.__mouseDown:
 if self.__newSelection:
 p = evt.position().toPoint()
 self.__selection.append(p)
 else:
 # moving the whole selection
 p = evt.position().toPoint() - self.__pBefore  # Offset
 self.__pBefore = evt.position().toPoint()
 # save position for next iteration
 self.__selection.translate(p)
 self.update()
 else:
 if self.__selection.boundingRect().isEmpty():
 return
-if self.__selection.containsPoint(evt.position().toPoint(),
+if self.__selection.containsPoint(
-Qt.FillRule.WindingFill):
+evt.position().toPoint(), Qt.FillRule.WindingFill
+):
 self.setCursor(Qt.CursorShape.OpenHandCursor)
 else:
 self.setCursor(Qt.CursorShape.CrossCursor)
 def mouseReleaseEvent(self, evt):
 """
 Protected method to handle mouse button releases.
 @param evt mouse release event (QMouseEvent)
 """
 self.__mouseDown = False
 self.__newSelection = False
-if self.__selection.containsPoint(evt.position().toPoint(),
+if self.__selection.containsPoint(
-Qt.FillRule.WindingFill):
+evt.position().toPoint(), Qt.FillRule.WindingFill
+):
 self.setCursor(Qt.CursorShape.OpenHandCursor)
 self.update()
 def mouseDoubleClickEvent(self, evt):
 """
 Protected method to handle mouse double clicks.
 @param evt mouse double click event (QMouseEvent)
 """
 self.__grabRegion()
 def keyPressEvent(self, evt):
 """
 Protected method to handle key presses.
 @param evt key press event (QKeyEvent)
 """
 if evt.key() == Qt.Key.Key_Escape:
 self.grabbed.emit(QPixmap())
 elif evt.key() in [Qt.Key.Key_Enter, Qt.Key.Key_Return]:
 self.__grabRegion()
 else:
 evt.ignore()
 def __grabRegion(self):
 """
 Private method to grab the selected region (i.e. do the snapshot).
 """
 pol = QPolygon(self.__selection)
 if not pol.isEmpty():
 self.__grabbing = True
 xOffset = self.__pixmap.rect().x() - pol.boundingRect().x()
 yOffset = self.__pixmap.rect().y() - pol.boundingRect().y()
 translatedPol = pol.translated(xOffset, yOffset)
 pixmap2 = QPixmap(pol.boundingRect().size())
 pixmap2.fill(Qt.GlobalColor.transparent)
 pt = QPainter()
 pt.begin(pixmap2)
-if pt.paintEngine().hasFeature(
+if pt.paintEngine().hasFeature(QPaintEngine.PaintEngineFeature.PorterDuff):
-QPaintEngine.PaintEngineFeature.PorterDuff
-):
 pt.setRenderHints(
-QPainter.RenderHint.Antialiasing |
+QPainter.RenderHint.Antialiasing
-QPainter.RenderHint.SmoothPixmapTransform,
+| QPainter.RenderHint.SmoothPixmapTransform,
-True)
+True,
+)
 pt.setBrush(Qt.GlobalColor.black)
 pt.setPen(QPen(QBrush(Qt.GlobalColor.black), 0.5))
 pt.drawPolygon(translatedPol)
-pt.setCompositionMode(
+pt.setCompositionMode(QPainter.CompositionMode.CompositionMode_SourceIn)
-QPainter.CompositionMode.CompositionMode_SourceIn)
 else:
 pt.setClipRegion(QRegion(translatedPol))
-pt.setCompositionMode(
+pt.setCompositionMode(QPainter.CompositionMode.CompositionMode_Source)
-QPainter.CompositionMode.CompositionMode_Source)
 pt.drawPixmap(pixmap2.rect(), self.__pixmap, pol.boundingRect())
 pt.end()
 self.grabbed.emit(pixmap2)

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Snapshot/SnapshotFreehandGrabber.py

src/eric7/Snapshot/SnapshotFreehandGrabber.py