def draw_selection_rect(self, painter):
cr, sr = self.target, self.selection_state.rect
painter.setPen(self.SELECT_PEN)
painter.setRenderHint(QPainter.RenderHint.Antialiasing, False)
if self.selection_state.current_mode == 'selected':
# Shade out areas outside the selection rect
for r in (
QRectF(cr.topLeft(), QPointF(sr.left(),
cr.bottom())), # left
QRectF(QPointF(sr.left(), cr.top()), sr.topRight()), # top
QRectF(QPointF(sr.right(), cr.top()),
cr.bottomRight()), # right
QRectF(sr.bottomLeft(), QPointF(sr.right(),
cr.bottom())), # bottom
):
painter.fillRect(r, self.SHADE_COLOR)
dr = self.get_drag_rect()
if self.selection_state.in_selection and dr is not None:
# Draw the resize rectangle
painter.save()
painter.setCompositionMode(
QPainter.CompositionMode.RasterOp_SourceAndNotDestination)
painter.setClipRect(sr.adjusted(1, 1, -1, -1))
painter.drawRect(dr)
painter.restore()
# Draw the selection rectangle
painter.setCompositionMode(
QPainter.CompositionMode.RasterOp_SourceAndNotDestination)
painter.drawRect(sr)
def __call__(self, canvas):
if canvas.has_selection and canvas.selection_state.rect is not None:
pimg = self.after_image
img = self.after_image = QImage(canvas.current_image)
rect = QRectF(*get_selection_rect(img, canvas.selection_state.rect, canvas.target))
p = QPainter(img)
p.setRenderHint(QPainter.RenderHint.SmoothPixmapTransform, True)
p.drawImage(rect, pimg, QRectF(pimg.rect()))
p.end()
return self.after_image
def paint_background(self, painter):
br = 12 # border_radius
bw = 1 # border_width
pal = self.palette()
c = pal.color(QPalette.ColorRole.Window)
c.setAlphaF(0.9)
p = QPainterPath()
p.addRoundedRect(QRectF(self.rect()), br, br)
painter.fillPath(p, c)
p.addRoundedRect(QRectF(self.rect()).adjusted(bw, bw, -bw, -bw), br, br)
painter.fillPath(p, pal.color(QPalette.ColorRole.WindowText))
def draw_pixmap(self, painter):
p = self.current_scaled_pixmap
try:
dpr = self.devicePixelRatioF()
except AttributeError:
dpr = self.devicePixelRatio()
width, height = int(p.width() / dpr), int(p.height() / dpr)
pwidth, pheight = self.last_canvas_size
x = int(abs(pwidth - width) / 2.)
y = int(abs(pheight - height) / 2.)
self.target = QRectF(x, y, width, height)
painter.drawPixmap(self.target, p, QRectF(p.rect()))
def drawForeground(self, g, rect):
g.setBrush(Color.flower)
g.setPen(no_pen)
for it in self.all(Cell):
if it.flower:
poly = _flower_poly.translated(it.scenePos())
g.drawPolygon(poly)
g.setBrush(QBrush(qt.NoBrush))
pen = QPen(Color.flower_border, 2)
pen.setCosmetic(True)
g.setPen(pen)
for it in self.all(Cell):
if it.flower:
poly = _flower_poly.translated(it.scenePos())
g.drawPolygon(poly)
g.setPen(no_pen)
g.setBrush(Color.beam)
for it in self.all(Column):
if it.beam:
poly = QPolygonF(QRectF(-0.03, 0.525, 0.06, 1e6))
poly = QTransform().translate(it.scenePos().x(),
it.scenePos().y()).rotate(
it.rotation()).map(poly)
poly = poly.intersected(QPolygonF(rect))
g.drawConvexPolygon(poly)
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.setAcceptDrops(True)
self.setMouseTracking(True)
self.setFocusPolicy(Qt.FocusPolicy.ClickFocus)
self.selection_state = SelectionState()
self.undo_stack = u = QUndoStack()
u.setUndoLimit(10)
u.canUndoChanged.connect(self.emit_undo_redo_state)
u.canRedoChanged.connect(self.emit_undo_redo_state)
self.original_image_data = None
self.is_valid = False
self.original_image_format = None
self.current_image = None
self.current_scaled_pixmap = None
self.last_canvas_size = None
self.target = QRectF(0, 0, 0, 0)
self.undo_action = a = self.undo_stack.createUndoAction(
self,
_('Undo') + ' ')
a.setIcon(QIcon(I('edit-undo.png')))
self.redo_action = a = self.undo_stack.createRedoAction(
self,
_('Redo') + ' ')
a.setIcon(QIcon(I('edit-redo.png')))
def paint(self, painter, option, index):
QStyledItemDelegate.paint(self, painter, option, self.dummy_index)
painter.save()
painter.setClipRect(QRectF(option.rect))
painter.translate(option.rect.topLeft())
self.to_doc(index, option).drawContents(painter)
painter.restore()
def fit(self):
rect = self.scene.itemsBoundingRect().adjusted(-0.3, -0.3, 0.3, 0.3)
self.setSceneRect(rect)
self.fitInView(rect, qt.KeepAspectRatio)
zoom = self.transform().mapRect(QRectF(0, 0, 1, 1)).width()
if zoom > 100:
self.resetTransform()
self.scale(100, 100)
def paint(self, painter, option, index):
painter.save()
painter.setClipRect(QRectF(option.rect))
if hasattr(QStyle, 'CE_ItemViewItem'):
QApplication.style().drawControl(QStyle.ControlElement.CE_ItemViewItem, option, painter)
elif option.state & QStyle.StateFlag.State_Selected:
painter.fillRect(option.rect, option.palette.highlight())
painter.translate(option.rect.topLeft())
self.to_doc(index).drawContents(painter)
painter.restore()
def get_drag_rect(self):
sr = self.selection_state.rect
dc = self.selection_state.drag_corner
if None in (sr, dc):
return
dx, dy = self.dc_size
if None in dc:
# An edge
if dc[0] is None:
top = sr.top() if dc[1] == 'top' else sr.bottom() - dy
ans = QRectF(sr.left() + dx, top, sr.width() - 2 * dx, dy)
else:
left = sr.left() if dc[0] == 'left' else sr.right() - dx
ans = QRectF(left, sr.top() + dy, dx, sr.height() - 2 * dy)
else:
# A corner
left = sr.left() if dc[0] == 'left' else sr.right() - dx
top = sr.top() if dc[1] == 'top' else sr.bottom() - dy
ans = QRectF(left, top, dx, dy)
return ans
def __init__(self, scene):
QGraphicsView.__init__(self, scene)
self.scene = scene
self.setBackgroundBrush(QBrush(qt.white))
self.setResizeAnchor(QGraphicsView.AnchorViewCenter)
self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
self.setRenderHints(self.renderHints()|QPainter.Antialiasing)
self.setHorizontalScrollBarPolicy(qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(qt.ScrollBarAlwaysOff)
inf = -1e10
self.setSceneRect(QRectF(QPointF(-inf, -inf), QPointF(inf, inf)))
self.scale(50, 50) #*1.00955
def __call__(self, painter, rect, color_theme, title_block, subtitle_block, footer_block):
painter.fillRect(rect, self.color1)
r = QRect(0, int(title_block.position.y), rect.width(),
title_block.height + subtitle_block.height + subtitle_block.line_spacing // 2 + title_block.leading)
painter.save()
p = QPainterPath()
p.addRoundedRect(QRectF(r), 10, 10 * r.width()/r.height(), Qt.SizeMode.RelativeSize)
painter.setClipPath(p)
painter.setRenderHint(QPainter.RenderHint.Antialiasing)
painter.fillRect(r, self.color2)
painter.restore()
r = QRect(0, 0, int(title_block.position.x), rect.height())
painter.fillRect(r, self.color2)
return self.ccolor2, self.ccolor2, self.ccolor1
def wheelEvent(self, e):
try:
d = e.angleDelta().y()
except AttributeError:
d = e.delta()
d = 1.0015**d #1.00005
zoom = self.transform().scale(d, d).mapRect(QRectF(0, 0, 1, 1)).width()
if zoom<10 and d<1:
return
elif zoom>350 and d>1:
return
#self.resetTransform()
self.scale(d, d)
def members(self):
try:
sr = self.scene().sceneRect()
except AttributeError:
return
poly = QPolygonF(QRectF(-0.001, 0.05, 0.002, 2*max(sr.width(), sr.height())))
if abs(self.rotation())>1e-2:
poly = QTransform().rotate(self.rotation()).map(poly)
poly.translate(self.scenePos())
items = self.scene().items(poly)
for it in items:
if isinstance(it, Cell):
if not poly.containsPoint(it.pos(), qt.OddEvenFill):
continue
yield it
def mouseMoveEvent(self, ev):
changed = False
if self.selection_state.in_selection:
changed = True
self.selection_state.in_selection = False
self.selection_state.drag_corner = None
pos = ev.pos()
cursor = Qt.CursorShape.ArrowCursor
try:
if not self.target.contains(pos):
return
if ev.buttons() & Qt.MouseButton.LeftButton:
if self.selection_state.last_press_point is not None and self.selection_state.current_mode is not None:
if self.selection_state.current_mode == 'select':
self.selection_state.rect = QRectF(
self.selection_state.last_press_point,
pos).normalized()
changed = True
elif self.selection_state.last_drag_pos is not None:
self.selection_state.in_selection = True
self.selection_state.drag_corner = self.selection_state.dragging
dp = pos - self.selection_state.last_drag_pos
self.selection_state.last_drag_pos = pos
self.move_selection(dp)
cursor = self.get_cursor()
changed = True
else:
if self.selection_state.rect is None or not self.selection_state.rect.contains(
pos):
return
if self.selection_state.current_mode == 'selected':
if self.selection_state.rect is not None and self.selection_state.rect.contains(
pos):
self.selection_state.drag_corner = self.get_drag_corner(
pos)
self.selection_state.in_selection = True
cursor = self.get_cursor()
changed = True
finally:
if changed:
self.update()
self.setCursor(cursor)
def boundingRect(self):
return QRectF(0, 0, self.width, self.height)