def setGeometry(self, rect: QRect):
if self.item is None or self.last_received_rect == rect:
return
self.last_received_rect = rect
proper_size = self.calculate_proper_size(rect.size())
proper_location = SquareLayout.calculate_center_location(
rect.size(), proper_size)
self.geometry_rect = QRect(proper_location, proper_size)
self.item.setGeometry(self.geometry_rect)
self.item.widget().show()
super().setGeometry(self.geometry_rect)
def printImage(self): #Ok
"""Imprimir Imagem
"""
printer = QPrinter()
printer.setOutputFormat(QPrinter.NativeFormat)
prnt_dlg = QPrintDialog(printer)
if (prnt_dlg.exec_() == QPrintDialog.Accepted):
painter = QPainter()
painter.begin(printer)
rect = QRect(painter.viewport())
size = QSize(self.img_lbl.pixmap().size())
size.scale(rect.size(), Qt.KeepAspectRatio)
painter.setViewport(rect.x(), rect.y(), size.width(),
size.height())
painter.setWindow(self.img_lbl.pixmap().rect())
painter.drawPixmap(0, 0, self.img_lbl.pixmap())
painter.end()
def draw_wfm_pillow(rect: QRect, wfm_arr: WFMArray) -> QImage:
vmin, vmax = -20, 120
vsize = vmax - vmin
in_height, in_width = wfm_arr.shape
in_rect = QRect(0, 0, in_width, in_height)
rect_h, rect_w = rect.height(), rect.width()
h_scale = rect_h - 1
w_scale = rect_w - 1
wfm_arr['ypos'] = (wfm_arr['ypos'] * 100 / vmax * vsize -
vmin) / vsize * h_scale
wfm_arr['xpos'] *= w_scale
img = Image.new('RGBA', (rect_w, rect_h), (0, 0, 0, 0))
d = ImageDraw.Draw(img)
xy_arr = rfn.structured_to_unstructured(wfm_arr[['xpos', 'ypos']])
for y in range(in_height):
d.line(xy_arr[y], fill=(255, 255, 255, 255), width=1)
qimg = im.toqimage()
if in_rect != rect:
qimg = qimg.scaled(rect.size())
return qimg.mirrored(False, True)
def paint(
self, painter: QPainter, rect: QRect, mode: QIcon.Mode, state: QIcon.State
):
"""override"""
font = FIconEngine.font if hasattr(FIconEngine, "font") else painter.font()
# The following test is to avoid crash when running python widget outside the __main__.my
if not font:
font = painter.font()
return
painter.save()
if self.color:
painter.setPen(QPen(self.color))
else:
if mode == QIcon.Disabled:
painter.setPen(
QPen(self.palette.color(QPalette.Disabled, QPalette.ButtonText))
)
else:
painter.setPen(QPen(self.palette.color(QPalette.Active, QPalette.Text)))
font.setPixelSize(rect.size().width())
painter.setFont(font)
# painter.setRenderHint(QPainter.HighQualityAntialiasing, True)
painter.drawText(
rect, Qt.AlignCenter | Qt.AlignVCenter, str(chr(self.hex_character))
)
painter.restore()
def restoreGeometry(self, geometry):
"""
Restores the geometry of this subwindow
:param geometry: the saved state as a QByteArray instance
:return:
"""
if geometry.size() < 4:
return False
stream = QDataStream(geometry)
if stream.readUInt32() != 0x1D9D0CB:
return False
if stream.readUInt16() != 1:
return False
stream.readUInt16() # minorVersion is ignored.
x = stream.readInt64()
y = stream.readInt64()
width = stream.readInt64()
height = stream.readInt64()
restoredFrameGeometry = QRect(x, y, width, height)
x = stream.readInt64()
y = stream.readInt64()
width = stream.readInt64()
height = stream.readInt64()
restoredNormalGeometry = QRect(x, y, width, height)
maximized = stream.readUInt32()
fullScreen = stream.readUInt32()
frameHeight = 20
if not restoredFrameGeometry.isValid():
restoredFrameGeometry = QRect(QPoint(0, 0), self.sizeHint())
if not restoredNormalGeometry.isValid():
restoredNormalGeometry = QRect(QPoint(0, frameHeight),
self.sizeHint())
restoredFrameGeometry.moveTop(max(restoredFrameGeometry.top(), 0))
restoredNormalGeometry.moveTop(
max(restoredNormalGeometry.top(), 0 + frameHeight))
if maximized or fullScreen:
self.setGeometry(restoredNormalGeometry)
ws = self.windowState()
if maximized:
ws |= Qt.WindowMaximized
if fullScreen:
ws |= Qt.WindowFullScreen
self.setWindowState(ws)
else:
offset = QPoint()
self.setWindowState(self.windowState()
& ~(Qt.WindowMaximized | Qt.WindowFullScreen))
self.move(restoredFrameGeometry.topLeft() + offset)
self.resize(restoredNormalGeometry.size())
return True
def paint(self, painter: QPainter, rect: QRect, mode: QIcon.Mode,
state: QIcon.State):
"""override"""
font = FIconEngine.font if hasattr(FIconEngine,
"font") else painter.font()
painter.save()
if mode == QIcon.Disabled:
painter.setPen(
QPen(qApp.palette().color(QPalette.Disabled, QPalette.Text)))
else:
painter.setPen(QPen(self.color))
font.setPixelSize(rect.size().width())
painter.setFont(font)
# painter.setRenderHint(QPainter.HighQualityAntialiasing, True)
painter.drawText(rect, Qt.AlignCenter | Qt.AlignVCenter,
str(chr(self.hex_character)))
painter.restore()
def _locate_win_result(self, target_rect: QRect):
if target_rect.width() < 2 or target_rect.height() < 2:
return
# Trigger a resize to regular size if previous size was fitted to a window
self.img_view.change_viewer_size()
if self.locate_btn.key_modifier == 0 and self.img_view.height() > 0:
# No Key Modifier tries to keep aspect ratio
height_factor: float = self.img_view.height() / self.img_view.width()
height: int = round(target_rect.width() * height_factor)
target_rect.setHeight(height)
LOGGER.debug('Trying to keep aspect ratio at %s height factor. %s %s',
height_factor, target_rect.width(), height)
elif self.locate_btn.key_modifier == Qt.ControlModifier:
# Ctrl Key only moves window
self.img_view.move(target_rect.topLeft())
return
elif self.locate_btn.key_modifier == Qt.ShiftModifier:
# Shift/Any Key Modifier fits to window without respecting aspect ratio of image
pass
self.img_view.resize(target_rect.size())
self.img_view.move(target_rect.topLeft())
def on_geometry_change(self, size: QRect):
self.resize(size.size())
class SchematicEditor(QWidget):
def __init__(self, parent=None):
super().__init__(parent)
self.setMouseTracking(True)
self.setFocusPolicy(Qt.StrongFocus)
self.elements = list()
self.wires = list()
self.guidepoints = list()
self.guidelines = list()
self._ghost_wire = None
self.wiring_mode = False
self.closest_point = None
self._wire_start = None
self.select_rect = None
self.selected_elements = list()
self.moved = False
self.grabbed_element = None
self.grab_offset = None
def _draw_wire(self, painter, line, ghost):
p = QPen(Qt.black, 8, Qt.PenStyle.SolidLine, Qt.PenCapStyle.RoundCap)
path = QPainterPath(line.p1())
path.lineTo(line.p2())
stroker = QPainterPathStroker(p)
stroke = stroker.createStroke(path)
fill_color = QColor(255, 255, 255)
outline_color = QColor(0, 0, 0)
if ghost:
fill_color.setAlphaF(0.5)
outline_color.setAlphaF(0.5)
painter.setPen(QPen(outline_color, 2))
painter.fillPath(stroke, fill_color)
painter.drawPath(stroke)
def _draw_wires(self, painter):
path = QPainterPath()
for wire in self.wires:
path.moveTo(wire.p1())
path.lineTo(wire.p2())
p = QPen(Qt.black, 8, Qt.PenStyle.SolidLine, Qt.PenCapStyle.RoundCap)
stroker = QPainterPathStroker(p)
stroke = stroker.createStroke(path).simplified()
fill_color = QColor(255, 255, 255)
outline_color = QColor(0, 0, 0)
painter.setPen(QPen(outline_color, 2))
painter.fillPath(stroke, fill_color)
painter.drawPath(stroke)
def _draw_pin(self, painter, point):
fill_color = QColor(255, 255, 255)
outline_color = QColor(0, 0, 0)
painter.setBrush(fill_color)
painter.setPen(QPen(outline_color, 2))
painter.drawEllipse(point.x() - 4, point.y() - 4, 8, 8)
def paintEvent(self, *args):
painter = QPainter(self)
painter.setRenderHint(QPainter.HighQualityAntialiasing)
r = self.rect()
painter.fillRect(r, Qt.white)
for element in self.elements:
painter.translate(element.bounding_box.topLeft())
element.paint(painter)
painter.translate(-element.bounding_box.topLeft())
self._draw_wires(painter)
for element in self.elements:
for pin in element.pins():
p = pin.position + element.bounding_box.topLeft()
self._draw_pin(painter, p)
painter.setPen(QPen(Qt.red, 1, Qt.DashLine))
painter.setBrush(Qt.transparent)
for element in self.selected_elements:
bb = element.bounding_box
bb = bb.marginsAdded(QMargins(2, 2, 1, 1))
painter.drawRect(bb)
if self.select_rect is not None:
painter.setBrush(QColor(0, 0, 255, 64))
painter.setPen(QColor(0, 0, 255, 128))
painter.drawRect(self.select_rect)
if self.wiring_mode:
painter.setPen(QPen(Qt.red, 1, Qt.PenStyle.DotLine))
for line in self.guidelines:
painter.drawLine(line)
if self._ghost_wire:
self._draw_wire(painter, self._ghost_wire, True)
if self.closest_point is not None:
p = self.closest_point
painter.drawEllipse(p.x() - 4, p.y() - 4, 8, 8)
def _pick(self, p):
for element in self.elements:
if element.bounding_box.contains(p):
return element
return None
def _closest_guideline_point(self, point):
currd = None
closest = None
is_junction = False
for element in self.elements:
for pin in element.pins():
p = pin.position + element.bounding_box.topLeft()
d = QVector2D(p - point).lengthSquared()
if (currd is None or d < currd) and d < 2500:
currd = d
closest = p
is_junction = True
for wire in self.wires:
for p in (wire.p1(), wire.p2()):
d = QVector2D(p - point).lengthSquared()
if (currd is None or d < currd) and d < 2500:
currd = d
closest = p
is_junction = True
for line in self.guidelines:
p = _closest_point(line, point)
d = QVector2D(p - point).lengthSquared()
if not _is_point_on_line(line, p):
continue
if self._wire_start is not None:
delta = p - self._wire_start
if delta.x() != 0 and delta.y() != 0:
continue
if (currd is None or
((not is_junction and d < currd) or
(is_junction and abs(d - currd) > 100))) and d < 2500:
currd = d
closest = p
return closest
def _closest_assist_point(self, point):
gp = self._closest_guideline_point(point)
return gp
def mousePressEvent(self, e):
if self.wiring_mode:
pass
else:
self.grabbed_element = self._pick(e.pos())
if self.grabbed_element is not None:
self.grab_offset = self.grabbed_element.bounding_box.topLeft(
) - e.pos()
else:
self.select_rect = QRect(e.pos(), QSize(0, 0))
def mouseMoveEvent(self, e):
if self.wiring_mode:
self.closest_point = self._closest_assist_point(e.pos())
if self._wire_start is not None and self.closest_point is not None:
self._ghost_wire = QLine(self._wire_start, self.closest_point)
else:
self._ghost_wire = None
self.update()
else:
if self.grabbed_element is not None:
self.grabbed_element.bounding_box.moveTopLeft(e.pos() +
self.grab_offset)
self.moved = True
self.update()
elif self.select_rect is not None:
self.select_rect.setBottomRight(e.pos())
if self.select_rect.size() != QSize(0, 0):
self.selected_elements = list()
for element in self.elements:
if self.select_rect.contains(element.bounding_box):
self.selected_elements.append(element)
self.update()
def mouseReleaseEvent(self, e):
if self.wiring_mode:
if e.button() == Qt.RightButton:
self._wire_start = None
self.update()
elif self.closest_point is not None:
if self._wire_start is None:
self._wire_start = self.closest_point
elif self.closest_point != self._wire_start:
wire_end = self.closest_point
self.wires.append(QLine(self._wire_start, wire_end))
self._wire_start = None
self._build_guidelines()
self.update()
else:
moved = self.moved
if self.grabbed_element is not None:
self.grabbed_element = None
self.moved = False
if not moved:
self.selected_elements = list()
if self.select_rect is not None and self.select_rect.size(
) != QSize(0, 0):
for element in self.elements:
if self.select_rect.contains(element.bounding_box):
self.selected_elements.append(element)
else:
for element in self.elements:
bb = element.bounding_box
if bb.contains(e.pos()):
self.selected_elements.append(element)
break
self.select_rect = None
self.update()
def _build_guidelines(self):
self.guidelines = list()
for element in self.elements:
for pin in element.pins():
p = pin.position + element.bounding_box.topLeft()
if pin.direction.y() == 0:
if pin.direction.x() > 0:
self.guidelines.append(
QLine(p.x(), p.y(),
self.rect().width(), p.y()))
else:
self.guidelines.append(QLine(p.x(), p.y(), 0, p.y()))
self.guidelines.append(
QLine(p.x(), 0, p.x(),
self.rect().height()))
else:
if pin.direction.y() > 0:
self.guidelines.append(
QLine(p.x(), p.y(), p.x(),
self.rect().height()))
else:
self.guidelines.append(QLine(p.x(), p.y(), p.x(), 0))
self.guidelines.append(
QLine(0, p.y(),
self.rect().width(), p.y()))
for wire in self.wires:
for p in (wire.p1(), wire.p2()):
self.guidelines.append(
QLine(0, p.y(),
self.rect().width(), p.y()))
self.guidelines.append(
QLine(p.x(), 0, p.x(),
self.rect().height()))
def resizeEvent(self, e):
super().resizeEvent(e)
self._build_guidelines()
self.update()
def _leave_wiring_mode(self):
self.wiring_mode = False
def _enter_wiring_mode(self):
self.wiring_mode = True
self._ghost_wire = None
self.closest_point = None
self.selected_elements = list()
self._build_guidelines()
def keyReleaseEvent(self, e):
if e.key() == Qt.Key_W:
if not self.wiring_mode:
self._enter_wiring_mode()
self.wiring_mode = True
else:
self._leave_wiring_mode()
self.wiring_mode = False
self.update()
elif e.key() == Qt.Key_Escape:
if self.wiring_mode:
self._leave_wiring_mode()
self.wiring_mode = False
self.update()
