Source code for qpageview.magnifier

# -*- coding: utf-8 -*-
# This file is part of the qpageview package.
# Copyright (c) 2010 - 2019 by Wilbert Berendsen
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
# See for more information.

The Magnifier magnifies a part of the displayed document.

from PyQt5.QtCore import QEvent, QPoint, QRect, Qt
from PyQt5.QtGui import (
    QColor, QCursor, QPainter, QPalette, QPen, QRegion, QTransform)
from PyQt5.QtWidgets import QWidget

DRAG_SHORT = 1      # visible only while keeping the mouse button pressed
DRAG_LONG  = 2      # remain visible and drag when picked up with the mouse

[docs]class Magnifier(QWidget): """A Magnifier is added to a View with view.setMagnifier(). It is shown when a mouse button is pressed together with a modifier (by default Ctrl). It can then be resized by moving the mouse is with two buttons pressed, or by wheeling with resizemodifier pressed. Its size can be changed with resize() and the scale (defaulting to 3.0) with setScale(). If can also be shown programatically with the show() method. In this case it can be dragged with the left mouse button. Wheel zooming with the modifier (by default Ctrl) zooms the magnifier. Instance attributes: ``showmodifier``: the modifier to popup (Qt.ControlModifier) ``zoommodifier``: the modifier to wheel zoom (Qt.ControlModifier) ``resizemodifier``: the key to press for wheel resizing (Qt.ShiftModifier) ``showbutton``: the mouse button causing the magnifier to popup (by default Qt.LeftButton) ``resizebutton``: the extra mouse button to be pressed when resizing the magnifier (by default Qt.RightButton) ``MAX_EXTRA_ZOOM``: the maximum zoom (relative to the View's maximum zoom level) """ # modifier for show showmodifier = Qt.ControlModifier # modifier for wheel zoom zoommodifier = Qt.ControlModifier # extra modifier for wheel resize resizemodifier = Qt.ShiftModifier # button for show showbutton = Qt.LeftButton # extra button for resizing resizebutton = Qt.RightButton # Maximum extra zoom above the View.MAX_ZOOM MAX_EXTRA_ZOOM = 1.25 # Minimal size MIN_SIZE = 50 # Maximal size MAX_SIZE = 640 def __init__(self): super().__init__() self._dragging = False self._resizepos = None self._resizewidth = 0 self._scale = 3.0 self.setAutoFillBackground(True) self.setBackgroundRole(QPalette.Dark) self.resize(350, 350) self.hide()
[docs] def moveCenter(self, pos): """Called by the View, centers the widget on the given QPoint.""" r = self.geometry() r.moveCenter(pos) self.setGeometry(r)
[docs] def setScale(self, scale): """Sets the scale, relative to the dislayed size in the View.""" self._scale = scale self.update()
[docs] def scale(self): """Returns the scale, defaulting to 3.0 (=300%).""" return self._scale
[docs] def startShortDrag(self, pos): """Start a short drag (e.g. on ctrl+click).""" viewport = self.parent() self._dragging = DRAG_SHORT self.moveCenter(pos) self.raise_() viewport.setCursor(Qt.BlankCursor)
[docs] def endShortDrag(self): """End a short drag.""" viewport = self.parent() view = viewport.parent() viewport.unsetCursor() self.hide() self._resizepos = None self._dragging = False view.stopScrolling() # just if needed
[docs] def startLongDrag(self, pos): """Start a long drag (when we are already visible and then dragged).""" self._dragging = DRAG_LONG self._dragpos = pos self.setCursor(Qt.ClosedHandCursor)
[docs] def endLongDrag(self): """End a long drag.""" self._dragging = False self.unsetCursor() view = self.parent().parent() view.stopScrolling() # just if needed
[docs] def resizeEvent(self, ev): """Called on resize, sets our circular mask.""" self.setMask(QRegion(self.rect(), QRegion.Ellipse))
[docs] def moveEvent(self, ev): """Called on move, updates the contents.""" # we also update on paint events, but they are not generated if the # magnifiers fully covers the viewport self.update()
[docs] def eventFilter(self, viewport, ev): """Handle events on the viewport of the View.""" view = viewport.parent() if not self.isVisible(): if (ev.type() == QEvent.MouseButtonPress and ev.modifiers() == self.showmodifier and ev.button() == self.showbutton): # show and drag while button pressed: DRAG_SHORT self.startShortDrag(ev.pos()) return True elif ev.type() == QEvent.Paint: # if the viewport is painted, also update self.update() elif self._dragging == DRAG_SHORT: if ev.type() == QEvent.MouseButtonPress: if ev.button() == self.resizebutton: return True elif ev.type() == QEvent.MouseMove: if ev.buttons() == self.showbutton | self.resizebutton: # DRAG_SHORT is busy, both buttons are pressed: resize! if self._resizepos == None: self._resizepos = ev.pos() self._resizewidth = self.width() dy = 0 else: dy = (ev.pos() - self._resizepos).y() g = self.geometry() w = min(max(self.MIN_SIZE, self._resizewidth + 2 * dy), self.MAX_SIZE) self.resize(w, w) self.moveCenter( else: # just drag our center self.moveCenter(ev.pos()) view.scrollForDragging(ev.pos()) return True elif ev.type() == QEvent.MouseButtonRelease: if ev.button() == self.showbutton: # left button is released, stop dragging and/or resizing, hide self.endShortDrag() elif ev.button() == self.resizebutton: # right button is released, stop resizing, warp cursor to center self._resizepos = None QCursor.setPos(viewport.mapToGlobal(self.geometry().center())) ev.accept() return True elif ev.type() == QEvent.ContextMenu: self.endShortDrag() return False
[docs] def mousePressEvent(self, ev): """Start dragging the magnifier.""" if self._dragging == DRAG_SHORT: ev.ignore() elif not self._dragging and ev.button() == Qt.LeftButton: self.startLongDrag(ev.pos())
[docs] def mouseMoveEvent(self, ev): """Move the magnifier if we were dragging it.""" ev.ignore() if self._dragging == DRAG_LONG: ev.accept() pos = self.mapToParent(ev.pos()) self.move(pos - self._dragpos) view = self.parent().parent() view.scrollForDragging(pos)
[docs] def mouseReleaseEvent(self, ev): """The button is released, stop moving ourselves.""" ev.ignore() if self._dragging == DRAG_LONG and ev.button() == Qt.LeftButton: self.endLongDrag()
[docs] def wheelEvent(self, ev): """Implement zooming the magnifying glass.""" if ev.modifiers() & self.zoommodifier: ev.accept() if ev.modifiers() & self.resizemodifier: factor = 1.1 ** (ev.angleDelta().y() / 120) g = self.geometry() c = g.setWidth(int(min(max(g.width() * factor, self.MIN_SIZE), self.MAX_SIZE))) g.setHeight(int(min(max(g.height() * factor, self.MIN_SIZE), self.MAX_SIZE))) g.moveCenter(c) self.setGeometry(g) else: factor = 1.1 ** (ev.angleDelta().y() / 120) scale = self._scale * factor view = self.parent().parent() layout = view.pageLayout() scale = max(min(scale, view.MAX_ZOOM * self.MAX_EXTRA_ZOOM / layout.zoomFactor), view.MIN_ZOOM / layout.zoomFactor) self.setScale(scale) else: super().wheelEvent(ev)
[docs] def paintEvent(self, ev): """Called when paint is needed, finds out which page to magnify.""" view = self.parent().parent() layout = view.pageLayout() scale = max(min(self._scale, view.MAX_ZOOM * self.MAX_EXTRA_ZOOM / layout.zoomFactor), view.MIN_ZOOM / layout.zoomFactor) matrix = QTransform().scale(scale, scale) # the position of our center on the layout c = self.geometry().center() - view.layoutPosition() # make a region scaling back to the view scale rect = matrix.inverted()[0].mapRect(self.rect()) rect.moveCenter(c) region = QRegion(rect, QRegion.Ellipse) # touches the Pages we need to draw # our rect on the enlarged pages our_rect = self.rect() our_rect.moveCenter( # the virtual position of the whole scaled-up layout ev_rect = ev.rect().translated(our_rect.topLeft()) # draw shadow border? shadow = False if hasattr(view, "drawDropShadow") and view.dropShadowEnabled: shadow = True shadow_width = layout.spacing * scale // 2 painter = QPainter(self) for p in layout.pagesAt(region.boundingRect()): # get a (reused) the copy of the page page = p.copy(self, matrix) # now paint it rect = (page.geometry() & ev_rect).translated(-page.pos()) painter.translate(page.pos() - our_rect.topLeft()) if shadow: view.drawDropShadow(page, painter, shadow_width) page.paint(painter, rect, self.repaintPage) painter.restore() self.drawBorder(painter)
[docs] def drawBorder(self, painter): """Draw a nice looking glass border.""" painter.setRenderHint(QPainter.Antialiasing, True) painter.setPen(QPen(QColor(192, 192, 192, 128), 6)) painter.drawEllipse(self.rect().adjusted(2, 2, -2, -2))
[docs] def repaintPage(self, page): """Called when a Page was rendered in the background.""" ## TODO: smarter determination which part to update self.update()