class QImageEdit(QLabel):
    def __init__(self, parentQWidget=None):
        super(QImageEdit, self).__init__(parentQWidget)
        self.rubberBand = None
        self.move_rubberBand = False
        self.rubberBand_offset = None
        self.originPoint = None

    def setImage(self, image: QPixmap):
        self.setPixmap(image)

    def getImage(self) -> QPixmap:
        if self.rubberBand is not None:
            currentRect = self.rubberBand.geometry()
            return self.pixmap().copy(currentRect)
        else:
            return self.pixmap()

    def clear(self):
        super(QImageEdit, self).clear()
        if self.rubberBand is not None:
            self.rubberBand.deleteLater()
        self.rubberBand = None
        self.move_rubberBand = False
        self.rubberBand_offset = None
        self.originPoint = None

    def mousePressEvent(self, event):
        self.originPoint = event.pos()

        if self.rubberBand is None:
            self.rubberBand = QRubberBand(QRubberBand.Rectangle, self)
            self.rubberBand.setGeometry(QRect(self.originPoint, QSize()))
            self.rubberBand.show()
        else:
            if self.rubberBand.geometry().contains(self.originPoint):
                self.rubberBand_offset = \
                    self.originPoint - self.rubberBand.pos()
                self.move_rubberBand = True
            else:
                self.rubberBand.hide()
                self.rubberBand.deleteLater()
                self.rubberBand = None
                self.move_rubberBand = False
                self.rubberBand_offset = None
                self.mousePressEvent(event)

    def mouseMoveEvent(self, event):
        newPoint = event.pos()
        if self.move_rubberBand:
            self.rubberBand.move(newPoint - self.rubberBand_offset)
        else:
            self.rubberBand.setGeometry(
                QRect(self.originPoint, newPoint).normalized())

    def mouseReleaseEvent(self, event):
        self.move_rubberBand = False
Example #2
0
class ResizableRubberBand(QWidget):
    """Wrapper to make QRubberBand mouse-resizable using QSizeGrip
    https://stackoverflow.com/questions/19066804/implementing-resize-handles-on-qrubberband-is-qsizegrip-relevant
    Source: http://stackoverflow.com/a/19067132/435253
    """

    def __init__(self, parent=None):
        super(ResizableRubberBand, self).__init__(parent)
        self.setMinimumSize(30, 30)
        self.setWindowFlags(Qt.SubWindow)
        self.layout = QHBoxLayout(self)
        self.layout.setContentsMargins(0, 0, 0, 0)

        self.grip1 = QSizeGrip(self)
        self.layout.addWidget(self.grip1, 0, Qt.AlignRight | Qt.AlignBottom)

        self.rubberband = QRubberBand(QRubberBand.Rectangle, self)
        self.rubberband.move(0, 0)
        self.rubberband.show()
        self.move_offset = None
        self.resize(150, 150)

        self.show()

    def resizeEvent(self, event):
        self.rubberband.resize(self.size())

    def mousePressEvent(self, event):
        if event.buttons() == Qt.LeftButton:
            self.move_offset = event.pos()

    def mouseMoveEvent(self, event):
        if event.buttons() == Qt.LeftButton:
            new_pos = self.mapToParent(event.pos() - self.move_offset)
            parent_rect = self.parent().rect()
            image_rect = self.parent().pixmap().rect()
            adjustment = parent_rect.bottomRight() - image_rect.bottomRight()
            y_offset = adjustment.y() / 2
            x_offset = adjustment.x() / 2

            new_pos.setX(max(x_offset, min(new_pos.x(), image_rect.width() - self.width() + x_offset)))
            new_pos.setY(max(y_offset, min(new_pos.y(), image_rect.height() - self.height() + y_offset)))

            self.move(new_pos)

    def mouseReleaseEvent(self, event):
        self.move_offset = None
Example #3
0
class ImageCropperDropper(QLabel):
	'''A QLabel that displays a rectangle when drawing a rectangle with the mouse'''

	cropped = Signal(QPixmap)
	fileDropped = Signal(QUrl)

	def __init__(self, mainwin):
		QLabel.__init__(self)

		self.setAcceptDrops(True)

		self.marker = QRubberBand(QRubberBand.Rectangle, self)
		self.markOrigin = self.markEnd = None

		self.setContextMenuPolicy(Qt.ActionsContextMenu)
		self.addAction(mainwin.cropAction)
		self.addAction(mainwin.saveAction)

	def setPixmap(self, pix):
		QLabel.setPixmap(self, pix)
		self.resize(pix.size())

		self.marker.hide()
		self.markOrigin = self.markEnd = None

	@Slot()
	def doCrop(self):
		'''Crop the pixmap using the user-drawn rectangle, emits cropped(QPixmap) signal'''
		if not self.markEnd:
			QMessageBox.warning(self, 'Error', 'Select a region to crop first')
			return
		cropzone = self._makeRect(self.markOrigin, self.markEnd)
		croppedpix = self.pixmap().copy(cropzone)

		self.setPixmap(croppedpix)
		self.cropped.emit(croppedpix)

	def _makeRect(self, p1, p2):
		'''Make a QRect based on QPoints p1 and p2.
		The 2 points must be 2 corners but don't need to be upper-left&lower-right'''
		x1, x2 = min(p1.x(), p2.x()), max(p1.x(), p2.x())
		y1, y2 = min(p1.y(), p2.y()), max(p1.y(), p2.y())
		return QRect().adjusted(x1, y1, x2, y2)

	def mouseMoveEvent(self, ev):
		if ev.buttons() != Qt.LeftButton:
			return QLabel.mouseMoveEvent(self, ev)
		self.markEnd = ev.pos()
		diffpoint = self.markEnd - self.markOrigin
		#~ self.marker.resize(diffpoint.x(), diffpoint.y())
		self.marker.setGeometry(self._makeRect(self.markOrigin, self.markEnd))
		#~ ev.accept()

	def mousePressEvent(self, ev):
		if ev.button() != Qt.LeftButton:
			return QLabel.mousePressEvent(self, ev)
		self.markOrigin = ev.pos()
		self.marker.move(ev.pos())
		self.marker.resize(QSize())
		self.marker.show()
		#~ ev.accept()

	def dragEnterEvent(self, ev):
		if ev.mimeData().hasUrls():
			ev.setDropAction(Qt.CopyAction)
			ev.accept()

	def dropEvent(self, ev):
		if ev.mimeData().hasUrls():
			ev.setDropAction(Qt.CopyAction)
			ev.accept()
			self.fileDropped.emit(ev.mimeData().urls()[0])
Example #4
0
class RubberBandManager(BaseVideoWindow):
    def __pre_init__(self, *args, **kwargs):
        super().__pre_init__(*args, **kwargs)
        self.rubberBand: Optional[QRubberBand] = None
        self.rubberBandActive = False
        self.rubberBandStartPos: Optional[QPoint] = None

    def __post_init__(self, *args, **kwargs):
        super().__post_init__(*args, **kwargs)
        self.actionSet_Position.triggered.connect(self.onSetPosition)

    @changeStatusDec(msg="Set position.")
    def onSetPosition(self):
        """Activate screen rectangle selector"""
        ci = self.tableView.selectionModel().currentIndex()
        if not ci.isValid():
            s = self.model.index(0, 0)
            e = self.model.index(0, len(VideoModel.headers) - 1)
            selection = QItemSelection(s, e)
            self.tableView.selectionModel().select(
                selection, QItemSelectionModel.SelectCurrent)
            ci = self.tableView.selectionModel().currentIndex()
        if not ci.isValid():
            QMessageBox.warning(self, 'Not selected', 'None row is selected')
            self.actionSet_Position.setChecked(False)
            return

        self.rubberBandActive = True
        self.grabMouse()
        return True

    def event(self, event: QEvent):
        if event.type() == QEvent.WindowDeactivate:
            if isinstance(event, QMouseEvent):
                self.mousePressEvent(event)
                return True
        return super().event(event)

    def keyPressEvent(self, a0: QtGui.QKeyEvent):
        if a0.key() == Qt.Key_Escape:
            self._onSetPositionClose()
        else:
            super().keyPressEvent(a0)

    def _onSetPositionClose(self):
        self.actionSet_Position.setChecked(False)
        self.rubberBandActive = False
        self.rubberBand = None
        self.releaseMouse()

    def mousePressEvent(self, a0: QtGui.QMouseEvent):
        if not self.rubberBandActive:
            super().mousePressEvent(a0)
            return

        child = self.childAt(a0.pos())
        if isinstance(child, QToolButton):
            if self.actionSet_Position in child.actions():
                self._onSetPositionClose()
                return

        if a0.button() != Qt.LeftButton:
            self.rubberBand = None
            return

        self.rubberBand = QRubberBand(QRubberBand.Rectangle)
        self.rubberBand.setGeometry(QRect())
        self.rubberBand.move(a0.globalPos())
        self.rubberBand.show()
        self.rubberBandStartPos = a0.globalPos()

    def mouseMoveEvent(self, a0: QtGui.QMouseEvent):
        if self.rubberBandActive and self.rubberBand:
            geom = QRect(self.rubberBandStartPos, a0.globalPos()).normalized()
            self.rubberBand.setGeometry(geom)
        else:
            return super().mouseMoveEvent(a0)

    def mouseReleaseEvent(self, a0: QtGui.QMouseEvent):
        if self.rubberBandActive and self.rubberBand:
            row = self.tableView.selectionModel().currentIndex()
            geom = QRect(self.rubberBandStartPos, a0.globalPos()).normalized()
            self.model.setPosition(row, geom)
            self._onSetPositionClose()

        super().mouseReleaseEvent(a0)
Example #5
0
class ResizableRubberBandWithGrip(QWidget):

    # containerResized = Signal(QSize)
    enter_or_return_key_pressed = pyqtSignal(QRect)
    esc_key_pressed = pyqtSignal()

    # ---------------------------------------------------------------------
    def __init__(self, parent=None):

        super(ResizableRubberBandWithGrip, self).__init__(parent)
        self.setAttribute(Qt.WA_DeleteOnClose)

        self.setWindowTitle("Defter: Screenshot")

        self.setWindowFlags(Qt.FramelessWindowHint | Qt.WindowStaysOnTopHint)

        self.setAttribute(Qt.WA_TranslucentBackground)
        self.setAttribute(Qt.WA_NoSystemBackground)

        # self.setAttribute(Qt.WA_PaintOnScreen)
        # self.setAttribute(Qt.WA_OpaquePaintEvent, False)
        # self.setStyleSheet("QWidget{background:transparent;}")
        # self.setStyleSheet("QWidget{background-color:none;}")
        # self.setStyleSheet("background-color: rgba(255, 255, 255, 40%);")

        # self.setWindowOpacity(0.7)

        layout = QHBoxLayout(self)
        layout.setContentsMargins(0, 0, 0, 0)

        grip1 = MySizeGrip(self)
        # grip2 = QSizeGrip(self)
        # grip3 = QSizeGrip(self)
        grip4 = MySizeGrip(self)
        layout.addWidget(grip1, 0, Qt.AlignLeft | Qt.AlignTop)
        # layout.addWidget(grip3, 0, Qt.AlignRight | Qt.AlignTop)
        # layout.addWidget(grip2, 0, Qt.AlignLeft | Qt.AlignBottom)
        layout.addWidget(grip4, 0, Qt.AlignRight | Qt.AlignBottom)
        self.rubberband = QRubberBand(QRubberBand.Rectangle, self)
        self.rubberband.move(0, 0)
        self.rubberband.show()

        self.show()

    def mousePressEvent(self, event):
        self._mousePressPos = None
        self._mouseMovePos = None
        if event.button() == Qt.LeftButton:
            self._mousePressPos = event.globalPos()
            self._mouseMovePos = event.globalPos()

        super(ResizableRubberBandWithGrip, self).mousePressEvent(event)

    def mouseMoveEvent(self, event):
        if event.buttons() == Qt.LeftButton:
            # adjust offset from clicked point to origin of widget
            currPos = self.mapToGlobal(self.pos())
            globalPos = event.globalPos()
            diff = globalPos - self._mouseMovePos
            newPos = self.mapFromGlobal(currPos + diff)
            self.move(newPos)

            self._mouseMovePos = globalPos

        super(ResizableRubberBandWithGrip, self).mouseMoveEvent(event)

    def mouseReleaseEvent(self, event):
        if self._mousePressPos:
            moved = event.globalPos() - self._mousePressPos
            if moved.manhattanLength() > 3:
                event.ignore()
                return

        super(ResizableRubberBandWithGrip, self).mouseReleaseEvent(event)

    # ---------------------------------------------------------------------
    def resizeEvent(self, event):

        # self.containerResized.emit((self.size()))
        self.rubberband.resize(self.size())
        super(ResizableRubberBandWithGrip, self).resizeEvent(event)

    # ---------------------------------------------------------------------
    def mouseDoubleClickEvent(self, event):
        self.hide()
        self.enter_or_return_key_pressed.emit(self.geometry())
        # self.close()
        # self.deleteLater()

    # ---------------------------------------------------------------------
    def keyPressEvent(self, event):

        if event.key() == Qt.Key_Escape:
            self.esc_key_pressed.emit()
        elif event.key() == Qt.Key_Enter or Qt.Key_Return:
            self.hide()
            self.enter_or_return_key_pressed.emit(self.geometry())
            # self.close()
            # self.deleteLater()

        # return ResizableRubberBandWithGripForImageResizing.keyPressEvent(self, event)
        super(ResizableRubberBandWithGrip, self).keyPressEvent(event)
Example #6
0
class ImageCropperDropper(QLabel):
    '''A QLabel that displays a rectangle when drawing a rectangle with the mouse'''

    cropped = Signal(QPixmap)
    fileDropped = Signal(QUrl)

    def __init__(self, mainwin):
        QLabel.__init__(self)

        self.setAcceptDrops(True)

        self.marker = QRubberBand(QRubberBand.Rectangle, self)
        self.markOrigin = self.markEnd = None

        self.setContextMenuPolicy(Qt.ActionsContextMenu)
        self.addAction(mainwin.cropAction)
        self.addAction(mainwin.saveAction)

    def setPixmap(self, pix):
        QLabel.setPixmap(self, pix)
        self.resize(pix.size())

        self.marker.hide()
        self.markOrigin = self.markEnd = None

    @Slot()
    def doCrop(self):
        '''Crop the pixmap using the user-drawn rectangle, emits cropped(QPixmap) signal'''
        if not self.markEnd:
            QMessageBox.warning(self, 'Error', 'Select a region to crop first')
            return
        cropzone = self._makeRect(self.markOrigin, self.markEnd)
        croppedpix = self.pixmap().copy(cropzone)

        self.setPixmap(croppedpix)
        self.cropped.emit(croppedpix)

    def _makeRect(self, p1, p2):
        '''Make a QRect based on QPoints p1 and p2.
		The 2 points must be 2 corners but don't need to be upper-left&lower-right'''
        x1, x2 = min(p1.x(), p2.x()), max(p1.x(), p2.x())
        y1, y2 = min(p1.y(), p2.y()), max(p1.y(), p2.y())
        return QRect().adjusted(x1, y1, x2, y2)

    def mouseMoveEvent(self, ev):
        if ev.buttons() != Qt.LeftButton:
            return QLabel.mouseMoveEvent(self, ev)
        self.markEnd = ev.pos()
        diffpoint = self.markEnd - self.markOrigin
        #~ self.marker.resize(diffpoint.x(), diffpoint.y())
        self.marker.setGeometry(self._makeRect(self.markOrigin, self.markEnd))
        #~ ev.accept()

    def mousePressEvent(self, ev):
        if ev.button() != Qt.LeftButton:
            return QLabel.mousePressEvent(self, ev)
        self.markOrigin = ev.pos()
        self.marker.move(ev.pos())
        self.marker.resize(QSize())
        self.marker.show()
        #~ ev.accept()

    def dragEnterEvent(self, ev):
        if ev.mimeData().hasUrls():
            ev.setDropAction(Qt.CopyAction)
            ev.accept()

    def dropEvent(self, ev):
        if ev.mimeData().hasUrls():
            ev.setDropAction(Qt.CopyAction)
            ev.accept()
            self.fileDropped.emit(ev.mimeData().urls()[0])