def show_node_choice_widget(self, pos, nodes=None):
"""Opens the node choice dialog in the scene."""
# calculating position
self.node_place_pos = self.mapToScene(pos)
dialog_pos = QPoint(pos.x() + 1, pos.y() + 1)
# ensure that the node_choice_widget stays in the viewport
if dialog_pos.x() + self.node_choice_widget.width(
) / self.total_scale_div > self.viewport().width():
dialog_pos.setX(dialog_pos.x() -
(dialog_pos.x() + self.node_choice_widget.width() /
self.total_scale_div - self.viewport().width()))
if dialog_pos.y() + self.node_choice_widget.height(
) / self.total_scale_div > self.viewport().height():
dialog_pos.setY(dialog_pos.y() -
(dialog_pos.y() +
self.node_choice_widget.height() /
self.total_scale_div - self.viewport().height()))
dialog_pos = self.mapToScene(dialog_pos)
# open nodes dialog
# the dialog emits 'node_chosen' which is connected to self.place_node,
# so this all continues at self.place_node below
self.node_choice_widget.update_list(
nodes if nodes is not None else self.all_nodes)
self.node_choice_widget.update_view()
self.node_choice_proxy.setPos(dialog_pos)
self.node_choice_proxy.show()
self.node_choice_widget.refocus()
def dropEvent(self, event):
if event.mimeData().hasText():
mime = event.mimeData()
pieces = mime.text().split()
position = event.pos()
hotSpot = QPoint()
hotSpotPos = mime.data('application/x-hotspot').split(' ')
if len(hotSpotPos) == 2:
hotSpot.setX(hotSpotPos[0].toInt()[0])
hotSpot.setY(hotSpotPos[1].toInt()[0])
for piece in pieces:
newLabel = DragLabel(piece, self)
newLabel.move(position - hotSpot)
newLabel.show()
position += QPoint(newLabel.width(), 0)
if event.source() in self.children():
event.setDropAction(Qt.MoveAction)
event.accept()
else:
event.acceptProposedAction()
else:
event.ignore()
def set_shade(self, shade: bool):
if shade == self.shade:
return
self.shade = shade
if self.shade:
self.previous_window_geom = self.window().size()
self.previous_window_min_size = self.window().minimumSize()
top_right = self.window().geometry().topRight()
self._inner.hide()
self.window().setMinimumSize(self._buttons.sizeHint())
size = self._buttons.sizeHint()
self.window().resize(size)
new_top_left = QPoint(top_right)
new_top_left.setX(top_right.x() - size.width())
self.window().move(new_top_left)
else:
pos = self.window().geometry().topRight()
self._inner.show()
if hasattr(self, "previous_window_geom"):
self.window().setMinimumSize(self.previous_window_min_size)
geom = self.previous_window_geom
else:
geom = self.window().sizeHint()
pos.setX(pos.x() - geom.width())
self.window().resize(geom)
self.window().move(pos)
def dropEvent(self, event):
if event.mimeData().hasText():
mime = event.mimeData()
pieces = mime.text().split()
position = event.pos()
hotSpot = QPoint()
hotSpotPos = mime.data('application/x-hotspot').split(' ')
if len(hotSpotPos) == 2:
hotSpot.setX(hotSpotPos[0].toInt()[0])
hotSpot.setY(hotSpotPos[1].toInt()[0])
for piece in pieces:
newLabel = DragLabel(piece, self)
newLabel.move(position - hotSpot)
newLabel.show()
position += QPoint(newLabel.width(), 0)
if event.source() in self.children():
event.setDropAction(Qt.MoveAction)
event.accept()
else:
event.acceptProposedAction()
else:
event.ignore()
def keyPressEvent(self, e: QtGui.QKeyEvent):
if not self.m_isEditing: return
if e.key() == QtCore.Qt.Key_Delete:
self.deleteLater()
# Moving container with arrows
if QApplication.keyboardModifiers() == QtCore.Qt.ControlModifier:
newPos = QPoint(self.x(), self.y())
if e.key() == QtCore.Qt.Key_Up:
newPos.setY(newPos.y() - 1)
if e.key() == QtCore.Qt.Key_Down:
newPos.setY(newPos.y() + 1)
if e.key() == QtCore.Qt.Key_Left:
newPos.setX(newPos.x() - 1)
if e.key() == QtCore.Qt.Key_Right:
newPos.setX(newPos.x() + 1)
self.move(newPos)
if QApplication.keyboardModifiers() == QtCore.Qt.ShiftModifier:
if e.key() == QtCore.Qt.Key_Up:
self.resize(self.width(), self.height() - 1)
if e.key() == QtCore.Qt.Key_Down:
self.resize(self.width(), self.height() + 1)
if e.key() == QtCore.Qt.Key_Left:
self.resize(self.width() - 1, self.height())
if e.key() == QtCore.Qt.Key_Right:
self.resize(self.width() + 1, self.height())
self.newGeometry.emit(self.geometry())
def paint(self, painter: QPainter, model: ShipModel = None):
assert self.is_set, 'Painter is not set'
# Draw ship
if model.is_alive:
_ship = self._ship_alive
else:
_ship = self._ship_dead
_pixmap = _ship.transformed(model.transform,
mode=Qt.SmoothTransformation)
_center_ship = self.transform(model.x - _pixmap.width() / 2,
model.y + _pixmap.height() / 2,
is_point=True)
if 0 <= _center_ship.x() <= self.parent.width(
) and 0 <= _center_ship.y() <= self.parent.height():
painter.drawPixmap(_center_ship, _pixmap)
# Draw life bar
_center_bar = self.transform(model.x - self._life_bar_xy[0],
model.y + self._life_bar_xy[1],
is_point=True)
painter.setPen(QPen(QColor(255, 0, 0), 0, Qt.NoPen))
painter.setBrush(QBrush(QColor(255, 0, 0)))
painter.drawRect(_center_bar.x(), _center_bar.y(),
self._life_bar_width, 5)
painter.setBrush(QBrush(QColor(0, 255, 0)))
painter.drawRect(_center_bar.x(), _center_bar.y(),
int(self._life_bar_width * model.life), 5)
painter.setPen(QPen(QColor(*model.color), 5, Qt.SolidLine))
_center_title = self.transform(model.x - 100,
model.y + 70,
is_point=True)
painter.setFont(
QFont('Open Sans', weight=QFont.Normal, pointSize=8))
painter.drawText(
QRect(_center_title.x(), _center_title.y(), 200, 25),
Qt.AlignHCenter | Qt.AlignTop, '<{}>'.format(model.name))
painter.setBrush(QBrush(QColor(*model.color)))
_center_point = self.transform(model.x, model.y, is_point=True)
painter.drawPoint(_center_point)
else:
_xy = QPoint(_center_ship)
if _center_ship.x() < 0:
_xy.setX(0)
if self.parent.width() < _center_ship.x():
_xy.setX(self.parent.width())
if _center_ship.y() < 0:
_xy.setY(0)
if self.parent.height() < _center_ship.y():
_xy.setY(self.parent.height())
painter.setPen(QPen(QColor(0, 0, 0), 30, Qt.SolidLine,
Qt.RoundCap))
painter.drawPoint(_xy)
painter.setPen(
QPen(QColor(*model.color), 25, Qt.SolidLine, Qt.RoundCap))
painter.drawPoint(_xy)
def getPosPopup(self):
pos = self.pos()
pos1 = self.mapToGlobal(pos)
pos2 = QPoint()
cRect = self.cursorRect()
pos2.setX(cRect.x())
pos2.setY(cRect.y())
return pos1 + pos2
def getPosPopup(self):
pos = self.pos()
pos1 = self.mapToGlobal(pos)
pos2 = QPoint()
cRect = self.cursorRect()
pos2.setX(cRect.x())
pos2.setY(cRect.y())
return pos1 + pos2
def drawAuthorDate(self, comment, painter, pen, start: QPoint,
end: QPoint):
""" Helper function for `self.paint()`, drawing author and date """
fontMetric = QFontMetrics(self.authorFont)
pen.setColor(QColor("#666699"))
painter.setPen(pen)
painter.setFont(self.authorFont)
painter.drawText(start, comment[1])
dateStart = QPoint(end.x(), end.y())
if comment[1] is not None and len(comment[1]) > 0:
dateStart.setX(dateStart.x() + self._authorDateQSeparation)
painter.drawText(dateStart, comment[2])
def _draw_overlays(self, painter: QPainter, level: Level):
painter.save()
for level_object in level.get_all_objects():
name = level_object.description.lower()
# only handle this specific enemy item for now
if isinstance(level_object, EnemyObject) and "invisible door" not in name:
continue
pos = level_object.get_rect(self.block_length).topLeft()
rect = level_object.get_rect(self.block_length)
# invisible coins, for example, expand and need to have multiple overlays drawn onto them
# set true by default, since for most overlays it doesn't matter
fill_object = True
# pipe entries
if "pipe" in name and "can go" in name:
if not self.draw_jumps_on_objects:
continue
fill_object = False
# center() is one pixel off for some reason
pos = rect.topLeft() + QPoint(*(rect.size() / 2).toTuple())
if "left" in name:
image = LEFT_ARROW
pos.setX(rect.right())
pos.setY(pos.y() - self.block_length / 2)
elif "right" in name:
image = RIGHT_ARROW
pos.setX(rect.left() - self.block_length)
pos.setY(pos.y() - self.block_length / 2)
elif "down" in name:
image = DOWN_ARROW
pos.setX(pos.x() - self.block_length / 2)
pos.setY(rect.top() - self.block_length)
else:
image = UP_ARROW
pos.setX(pos.x() - self.block_length / 2)
pos.setY(rect.bottom())
if not self._object_in_jump_area(level, level_object):
image = NO_JUMP
elif "door" == name or "door (can go" in name or "invisible door" in name:
fill_object = False
image = DOWN_ARROW
pos.setY(rect.top() - self.block_length)
if not self._object_in_jump_area(level, level_object):
image = NO_JUMP
# "?" - blocks, note blocks, wooden blocks and bricks
elif "'?' with" in name or "brick with" in name or "bricks with" in name or "block with" in name:
if not self.draw_items_in_blocks:
continue
pos.setY(pos.y() - self.block_length)
if "flower" in name:
image = FIRE_FLOWER
elif "leaf" in name:
image = LEAF
elif "continuous star" in name:
image = CONTINUOUS_STAR
elif "star" in name:
image = NORMAL_STAR
elif "multi-coin" in name:
image = MULTI_COIN
elif "coin" in name:
image = COIN
elif "1-up" in name:
image = ONE_UP
elif "vine" in name:
image = VINE
elif "p-switch" in name:
image = P_SWITCH
else:
image = EMPTY_IMAGE
# draw little arrow for the offset item overlay
arrow_pos = QPoint(pos)
arrow_pos.setY(arrow_pos.y() + self.block_length / 4)
painter.drawImage(arrow_pos, ITEM_ARROW.scaled(self.block_length, self.block_length))
elif "invisible" in name:
if not self.draw_invisible_items:
continue
if "coin" in name:
image = INVISIBLE_COIN
elif "1-up" in name:
image = INVISIBLE_1_UP
else:
image = EMPTY_IMAGE
elif "silver coins" in name:
if not self.draw_invisible_items:
continue
image = SILVER_COIN
else:
continue
if fill_object:
for x in range(level_object.rendered_width):
adapted_pos = QPoint(pos)
adapted_pos.setX(pos.x() + x * self.block_length)
image = image.scaled(self.block_length, self.block_length)
painter.drawImage(adapted_pos, image)
if level_object.selected:
painter.drawImage(adapted_pos, _make_image_selected(image))
else:
image = image.scaled(self.block_length, self.block_length)
painter.drawImage(pos, image)
painter.restore()
class TColorPickerSV(QWidget):
changed = Signal(QColor)
doubleClicked = Signal()
def __init__(self, parent):
super(TColorPickerSV, self).__init__(parent)
self.setStatusTip("Saturation, Value. To control use Arrows")
self._size = QSize(25, 25)
self._scale = 11
self.setMinimumSize(self._size * self._scale)
self._color = QColor(Qt.white)
self._pixmap = QPixmap()
self._pos = QPoint(24, 24)
self._hue = 0
self._saturation = 255
self._value = 255
def set_hue(self, hue):
hue = clamp(hue, 0, 360)
self._hue = hue if hue < 360 else 0
iw = self._size.width()
ih = self._size.height()
bpl = iw * 4
bits = bytearray(iw * ih * 4)
color = QColor()
for v in range(ih):
for s in range(iw):
color.setHsv(hue, 255.0 / (iw - 1) * s,
255.0 - 255.0 / (ih - 1) * v)
color = qcolor_linear_to_srgb(color)
(r, g, b, a) = color.getRgb()
# For 3ds Max use bits[index] = chr(value)
bits[bpl * v + 4 * s + 0] = b
bits[bpl * v + 4 * s + 1] = g
bits[bpl * v + 4 * s + 2] = r
# bits[bpl * v + 4*s + 3] = 0xff
img = QImage(bits, iw, ih, QImage.Format_RGB32)
self._pixmap = QPixmap.fromImage(img).scaled(self.minimumSize(),
Qt.KeepAspectRatio,
Qt.FastTransformation)
self.set_pos(self._pos)
def set_pos(self, pos):
iw = self._size.width() - 1
ih = self._size.height() - 1
self._pos.setX(clamp(pos.x(), 0, iw))
self._pos.setY(clamp(pos.y(), 0, ih))
self._saturation = clamp(255 * self._pos.x() / iw, 0, 255)
self._value = clamp(255 * self._pos.y() / ih, 0, 255)
self._color = QColor.fromHsv(self._hue, self._saturation, self._value)
self.update()
self.changed.emit(self._color)
def set_remap_pos(self, mouse_pos):
# Remap mouse position
pos = QPoint(int(mouse_pos.x() / self._scale),
int(self._size.height() - mouse_pos.y() / self._scale))
self.set_pos(pos)
def paintEvent(self, event):
painter = QPainter(self)
painter.drawPixmap(0, 0, self._pixmap)
painter.save()
painter.setCompositionMode(QPainter.RasterOp_SourceXorDestination)
pen = QPen(QBrush(Qt.white), 2., Qt.SolidLine, Qt.SquareCap,
Qt.MiterJoin)
painter.setPen(pen)
s = self._scale
painter.drawRect(
QRect(self._pos.x() * s - 1,
(self._size.height() - 1 - self._pos.y()) * s - 1, s + 2,
s + 2))
painter.restore()
def mouseMoveEvent(self, event):
self.set_remap_pos(event.pos())
event.accept()
def mousePressEvent(self, event):
self.set_remap_pos(event.pos())
event.accept()
def mouseDoubleClickEvent(self, event):
self.doubleClicked.emit()
event.accept()
def keyPressEvent(self, event):
key = event.key()
if key in [Qt.Key_Left, Qt.Key_Right, Qt.Key_Up, Qt.Key_Down]:
x, y = self._pos.x(), self._pos.y()
if key == Qt.Key_Left: x -= 1
if key == Qt.Key_Right: x += 1
if key == Qt.Key_Up: y += 1
if key == Qt.Key_Down: y -= 1
self.set_pos(QPoint(x, y))
event.accept()
def insertFeature(self):
if (self.x != -1 and self.y != -1):
print(self.x, self.y)
p1 = QPoint()
p1.setX(self.x)
p1.setY(self.y)
if self.x <= self.scrollf.x(
) + self.width and self.x >= self.scrollf.x(
) and self.y <= self.scrollf.y(
) + self.height and self.y >= self.scrollf.y():
rv = self.mapToGlobal(p1)
self.newp = self.fixedImageLB.mapFromGlobal(rv)
print("selected ", self.newp.x(), self.newp.y())
print('firstkeyf ', len(self.keypoints[0]))
cv2.circle(self.imgff,
(int(self.newp.x()), int(self.newp.y())), 5,
(0, 0, 0), -1)
height, width, channel = self.imgff.shape
bytesPerLine = 3 * width
qImg = QImage(self.imgff, width, height, bytesPerLine,
QImage.Format_RGB888)
self.fixedImageQI = qImg
pixMapf = QPixmap.fromImage(self.fixedImageQI)
self.fixedImageLB.setPixmap(pixMapf)
newpf = QPoint()
newpf.setX(self.newp.x())
newpf.setY(self.newp.y())
# newifk=[]
# for pointm in self.keypoints[0]:
# newifk.append(pointm)
# newifk.append(newpf)
self.keypoints[0].append(
cv2.KeyPoint(self.newp.x(), self.newp.y(), 5, _class_id=0))
elif self.x <= self.scrollm.x(
) + self.width and self.x >= self.scrollm.x(
) and self.y <= self.scrollm.y(
) + self.height and self.y >= self.scrollm.y():
rvm = self.mapToGlobal(p1)
self.newpm = self.movingImageLB.mapFromGlobal(rvm)
print("selected ", self.newpm.x(), self.newpm.y())
print('firstkeym ', len(self.keypointsM))
cv2.circle(self.imgmm,
(int(self.newpm.x()), int(self.newpm.y())), 5,
(0, 0, 0), -1)
height, width, channel = self.imgmm.shape
bytesPerLine = 3 * width
qImg = QImage(self.imgmm, width, height, bytesPerLine,
QImage.Format_RGB888)
self.movingImageQI = qImg
pixMapm = QPixmap.fromImage(self.movingImageQI)
self.movingImageLB.setPixmap(pixMapm)
# newpm = QPoint()
# newpm.setX(self.newpm.x())
# newpm.setY(self.newpm.y())
self.keypointsM.append(
cv2.KeyPoint(self.newpm.x(),
self.newpm.y(),
5,
_class_id=0))
print('s')
def removeFeature(self):
if (self.x != -1 and self.y != -1):
print(self.x, self.y)
p1 = QPoint()
p1.setX(self.x) # point.pt[0]
p1.setY(self.y) # point.pt[1]
self.selectedF = False
if self.x <= self.scrollf.x(
) + self.width and self.x >= self.scrollf.x(
) and self.y <= self.scrollf.y(
) + self.height and self.y >= self.scrollf.y():
rv = self.mapToGlobal(p1)
self.newp = self.fixedImageLB.mapFromGlobal(rv)
print("selected ", self.newp.x(), self.newp.y())
print('firstkeyf ', len(self.keypoints[0]))
cv2.circle(self.imgff,
(int(self.newp.x()), int(self.newp.y())), 5,
(0, 0, 0), -1)
height, width, channel = self.imgff.shape
bytesPerLine = 3 * width
qImg = QImage(self.imgff, width, height, bytesPerLine,
QImage.Format_RGB888)
self.fixedImageQI = qImg
pixMapf = QPixmap.fromImage(self.fixedImageQI)
self.fixedImageLB.setPixmap(pixMapf)
newk = []
for point in self.keypoints[0]:
if (int(point.pt[0]) <= int(self.newp.x()) + 2
and int(point.pt[0]) >= int(self.newp.x()) - 2):
if (int(point.pt[1]) <= int(self.newp.y()) + 2 and
int(point.pt[1]) >= int(self.newp.y()) - 2):
print('yes')
self.selectedF = True
else:
newk.append(point)
else:
newk.append(point)
if self.selectedF:
self.keypoints[0] = newk
elif self.x <= self.scrollm.x(
) + self.width and self.x >= self.scrollm.x(
) and self.y <= self.scrollm.y(
) + self.height and self.y >= self.scrollm.y():
self.selectedM = False
rvm = self.mapToGlobal(p1)
self.newpm = self.movingImageLB.mapFromGlobal(rvm)
print("selected ", self.newpm.x(), self.newpm.y())
print('firstkeym ', len(self.keypointsM))
cv2.circle(self.imgmm,
(int(self.newpm.x()), int(self.newpm.y())), 5,
(0, 0, 0), -1)
height, width, channel = self.imgmm.shape
bytesPerLine = 3 * width
qImg = QImage(self.imgmm, width, height, bytesPerLine,
QImage.Format_RGB888)
self.movingImageQI = qImg
pixMapm = QPixmap.fromImage(self.movingImageQI)
self.movingImageLB.setPixmap(pixMapm)
newmk = []
for pointm in self.keypointsM:
if (int(pointm.pt[0]) <= int(self.newpm.x()) + 2
and int(pointm.pt[0]) >= int(self.newpm.x()) - 2):
if (int(pointm.pt[1]) <= int(self.newpm.y()) + 2 and
int(pointm.pt[1]) >= int(self.newpm.y()) - 2):
print('yes') # remove this point
self.selectedM = True
else:
newmk.append(pointm)
else:
newmk.append(pointm)
if self.selectedM:
self.keypointsM = newmk
print('keym', len(self.keypointsM), len(self.descriptorsM))
class RetroDrawWidget(QWidget):
"""
Defines widget for displaying and handling all retro drawing.
"""
def __init__(self, fgIndex, bgIndex, palette, parent=None):
super(RetroDrawWidget, self).__init__(parent)
self.canvasSize = QSize(256, 192)
self.canvasCenter = QPoint(self.canvasSize.width() / 2,
self.canvasSize.height() / 2)
self.fgIndex = fgIndex
self.bgIndex = bgIndex
self.palette = palette
self.scale = 4
self.screenSize = self.canvasSize * self.scale
self.screenCenter = self.canvasCenter * self.scale
self.grid = QImage(self.screenSize, QImage.Format_RGBA8888)
self.grid.fill(QColor(0, 0, 0, 0))
for y in range(0, self.screenSize.height()):
for x in range(0, self.screenSize.width(), 8 * self.scale):
self.grid.setPixelColor(x, y, QColor(0, 0, 0, 255))
for x in range(0, self.screenSize.width()):
for y in range(0, self.screenSize.height(), 8 * self.scale):
self.grid.setPixelColor(x, y, QColor(0, 0, 0, 255))
self._gridEnabled = True
self._gridOpacity = 0.2
self._guideFilename = None
self._guide = None
self._guideEnabled = True
self._guideOpacity = 0.2
self._guideCoords = QPoint(0, 0)
self._guideZoom = 1.0
self._scratch = QImage(self.screenSize, QImage.Format_RGBA8888)
self._scratch.fill(QColor(0, 0, 0, 0))
self.drawable = ZXSpectrumBuffer()
self.setCursor(Qt.CrossCursor)
self._mouseLastPos = self.getLocalMousePos()
self._mouseDelta = QPoint(0, 0)
self._mousePressed = MouseButton.NONE
self._drawMode = DrawingMode.DOTTED
self._lineState = None
def encodeToJSON(self):
rdict = dict()
rdict["fg_index"] = self.fgIndex
rdict["bg_index"] = self.bgIndex
rdict["palette"] = self.palette
rdict["grid_enabled"] = self._gridEnabled
rdict["grid_opacity"] = self._gridOpacity
rdict["guide_filename"] = self._guideFilename
rdict["guide_enabled"] = self._guideEnabled
rdict["guide_opacity"] = self._guideOpacity
rdict["guide_coords_x"] = self._guideCoords.x()
rdict["guide_coords_y"] = self._guideCoords.y()
rdict["guide_zoom"] = self._guideZoom
rdict["drawable"] = self.drawable.encodeToJSON()
return rdict
def decodeFromJSON(self, json):
self.fgIndex = json["fg_index"]
self.bgIndex = json["bg_index"]
self.palette = json["palette"]
self._gridEnabled = json["grid_enabled"]
self._gridOpacity = json["grid_opacity"]
self._guideFilename = json["guide_filename"]
self._guide = QPixmap(self._guideFilename)
self._guideEnabled = json["guide_enabled"]
self._guideOpacity = json["guide_opacity"]
self._guideCoords.setX(json["guide_coords_x"])
self._guideCoords.setY(json["guide_coords_y"])
self._guideZoom = json["guide_zoom"]
self.drawable.decodeFromJSON(json["drawable"])
def sizeHint(self):
return self.screenSize
def minimumSizeHint(self):
return self.screenSize
def getLocalMousePos(self):
return self.mapFromGlobal(QCursor.pos())
def paintEvent(self, event):
super(RetroDrawWidget, self).paintEvent(event)
painter = QPainter(self)
rectTarget = self.rect()
rectSource = QRect(QPoint(0, 0), self.canvasSize)
painter.drawPixmap(rectTarget, self.drawable.qpixmap, rectSource)
if self._guide and self._guideEnabled:
painter.setOpacity(self._guideOpacity)
self._paintZoomedGuide(painter)
if self._gridEnabled:
painter.setOpacity(self._gridOpacity)
painter.drawImage(rectTarget, self.grid, rectTarget)
painter.setOpacity(1.0)
painter.drawImage(rectTarget, self._scratch, rectTarget)
painter.end()
def mousePressEvent(self, event):
self._mouseLastPos = self.getLocalMousePos()
if event.button() == Qt.LeftButton:
self._mousePressed = MouseButton.LEFT
elif event.button() == Qt.RightButton:
self._mousePressed = MouseButton.RIGHT
if self._drawMode == DrawingMode.PEN:
if self._mousePressed == MouseButton.LEFT:
self.doDraw(event.localPos(), True)
elif self._drawMode == DrawingMode.DOTTED:
if self._mousePressed == MouseButton.LEFT:
self.doDraw(event.localPos(), True)
elif self._mousePressed == MouseButton.RIGHT:
self.doDraw(event.localPos(), False)
elif self._drawMode == DrawingMode.ERASE:
if self._mousePressed == MouseButton.LEFT:
self.doDraw(event.localPos(), False)
elif self._drawMode == DrawingMode.LINE:
if self._mousePressed == MouseButton.LEFT:
self._lineState = [event.localPos(), event.localPos()]
painter = QPainter(self._scratch)
painter.setPen(Qt.black)
painter.drawLine(self._lineState[0], self._lineState[1])
painter.end()
self.update(self.rect())
elif self._drawMode == DrawingMode.ATTR:
if self._mousePressed == MouseButton.LEFT:
self.doDrawAttr(event.localPos())
def mouseReleaseEvent(self, event):
if self._drawMode == DrawingMode.LINE:
if self._mousePressed == MouseButton.LEFT and self._lineState:
self._lineState[1] = event.localPos()
painter = QPainter(self._scratch)
painter.setPen(Qt.black)
painter.drawLine(self._lineState[0], self._lineState[1])
self.doDrawLine(self._lineState[0], self._lineState[1])
painter.end()
self._lineState = None
self._scratch.fill(QColor(0, 0, 0, 0))
self.update(self.rect())
self._mousePressed = MouseButton.NONE
def mouseMoveEvent(self, event):
oldMousePos = self._mouseLastPos
newMousePos = self.getLocalMousePos()
self._mouseDelta = newMousePos - self._mouseLastPos
self._mouseLastPos = newMousePos
if self._drawMode == DrawingMode.PEN:
if self._mousePressed == MouseButton.LEFT:
self.doDrawLine(oldMousePos, newMousePos)
if self._drawMode == DrawingMode.DOTTED:
if self._mousePressed == MouseButton.LEFT:
self.doDraw(newMousePos, True)
elif self._mousePressed == MouseButton.RIGHT:
self.doDraw(newMousePos, False)
elif self._drawMode == DrawingMode.ERASE:
if self._mousePressed == MouseButton.LEFT:
self.doDraw(newMousePos, False)
elif self._drawMode == DrawingMode.GUIDE:
if self._mousePressed == MouseButton.LEFT:
self._guideCoords += self._mouseDelta
self.update(self.rect())
elif self._drawMode == DrawingMode.LINE:
if self._mousePressed == MouseButton.LEFT and self._lineState:
painter = QPainter(self._scratch)
self._scratch.fill(QColor(0, 0, 0, 0))
painter.setPen(Qt.black)
self._lineState[1] = event.localPos()
painter.drawLine(self._lineState[0], self._lineState[1])
painter.end()
self.update(self.rect())
elif self._drawMode == DrawingMode.ATTR:
if self._mousePressed == MouseButton.LEFT:
self.doDrawAttr(event.localPos())
def wheelEvent(self, event):
if self._mousePressed:
if self._drawMode == DrawingMode.GUIDE:
delta = event.pixelDelta().y() * 0.01
if delta != 0.0:
self._guideZoom += delta
self._guideZoom = self.clamp(self._guideZoom, 0.1, 8.0)
self.update(self.rect())
@staticmethod
def clamp(value, min, max):
if value < min:
return min
elif value > max:
return max
return value
def doDraw(self, localPos, setPixel):
x = localPos.x() // self.scale
y = localPos.y() // self.scale
if setPixel:
self.drawable.setPixel(x, y, self.fgIndex, self.bgIndex,
self.palette)
else:
self.drawable.erasePixel(x, y, self.fgIndex, self.bgIndex,
self.palette)
self.update(self.rect())
def doDrawAttr(self, localPos):
x = localPos.x() // self.scale
y = localPos.y() // self.scale
self.drawable.setAttr(x, y, self.fgIndex, self.bgIndex, self.palette)
self.update(self.rect())
def doDrawLine(self, localStartPos, localEndPos):
x1 = localStartPos.x() // self.scale
y1 = localStartPos.y() // self.scale
x2 = localEndPos.x() // self.scale
y2 = localEndPos.y() // self.scale
self.drawable.drawLine(x1, y1, x2, y2, self.fgIndex, self.bgIndex,
self.palette)
self.update(self.rect())
def setColor(self, fgIndex, bgIndex, palette):
self.fgIndex = fgIndex
self.bgIndex = bgIndex
self.palette = palette
def saveImage(self, filename, format=None):
self.drawable.saveBuffer(filename)
def setGrid(self, checked):
self._gridEnabled = checked
self.repaint()
def setGridOpacity(self, value):
self._gridOpacity = value / 100.0
self.repaint()
def setGuideImage(self, filename):
self._guideFilename = filename
self._guide = QPixmap(self._guideFilename)
self.repaint()
def setGuide(self, checked):
self._guideEnabled = checked
self.repaint()
def setGuideOpacity(self, value):
self._guideOpacity = value / 100.0
self.repaint()
def setMode(self, mode):
self._drawMode = mode
def clear(self):
self.drawable.clear(self.fgIndex, self.bgIndex, self.palette)
self.repaint()
def _paintZoomedGuide(self, painter):
guideZoom = self._guide.scaled(self._guide.width() * self._guideZoom,
self._guide.height() * self._guideZoom,
Qt.KeepAspectRatio)
pos = QPoint(
self._guideCoords.x() +
(self.screenCenter.x() - guideZoom.width() / 2),
self._guideCoords.y() +
(self.screenCenter.y() - guideZoom.height() / 2))
painter.drawPixmap(pos, guideZoom)
def copyGuide(self):
# This isn't the most efficient way to do this but it just needs to be
# reasonably fast
self.drawable.clear(self.fgIndex, self.bgIndex, self.palette)
guide_copy = QImage(self.screenSize, QImage.Format_RGBA8888)
guide_copy.fill(QColor("white"))
painter = QPainter(guide_copy)
self._paintZoomedGuide(painter)
shrunk_guide = guide_copy.smoothScaled(self.canvasSize.width(),
self.canvasSize.height())
mono_guide = shrunk_guide.convertToFormat(QImage.Format_Mono)
for x in range(0, self.canvasSize.width()):
for y in range(0, self.canvasSize.height()):
if mono_guide.pixel(x, y) == QColor("black"):
self.drawable.setPixel(x, y, self.fgIndex, self.bgIndex,
self.palette)
painter.end()
self.repaint()
def draw_mini_map(self, painter, is_full=False):
_pixmap_minimap = QPixmap(
QSize(min([self.width(), self.height()]),
min([self.width(), self.height()]))) if is_full else QPixmap(
QSize(350, 350))
if is_full:
_p_origin = QPoint((self.width() - _pixmap_minimap.width()) // 2,
(self.height() - _pixmap_minimap.height()) // 2)
else:
_p_origin = QPoint(self.width() - _pixmap_minimap.width(),
self.height() - _pixmap_minimap.height())
_pixmap_minimap.fill(QColor('#00284d'))
# DRAW DEAD ZONE
_dz_radius = self.controller.get_dead_zone_radius()
_xy = QPoint(*self.controller.get_dead_zone_center().tolist())
# GET MOBILE OBJECTS
_model_ships = self.controller.get_data_from_players(enemy_only=False)
_model_bolts = self.controller.get_data_from_bolts()
_model_asteroids = self.controller.get_data_from_asteroids()
# SET MINI MAP
_w_ratio = _pixmap_minimap.width() / (PartyConst.WIDTH * 1.25)
_h_ratio = _pixmap_minimap.height() / (PartyConst.HEIGHT * 1.25)
_minimap_painter = QPainter(_pixmap_minimap)
_minimap_painter.setOpacity(1)
for _ship in _model_ships:
_w = _ship.radius * _w_ratio
if _w < 3:
_w = 3
_x, _y = int(
_ship.x * _w_ratio) + _pixmap_minimap.width() // 2, int(
_ship.y * _h_ratio) + _pixmap_minimap.height() // 2
if _ship.is_alive:
_factor_1 = (time.time() * 2) % 2
_factor_2 = (time.time() * 2 + .5) % 2
_minimap_painter.setPen(
QPen(QColor('#ffffff'), 1, Qt.SolidLine))
_minimap_painter.setOpacity(1 - _factor_1)
_minimap_painter.drawEllipse(QPoint(_x, _y),
int(20 * _factor_1),
int(20 * _factor_1))
_minimap_painter.setOpacity(1 - _factor_2)
_minimap_painter.drawEllipse(QPoint(_x, _y),
int(20 * _factor_2),
int(20 * _factor_2))
_minimap_painter.setPen(
QPen(QColor(*_ship.color), _w, Qt.SolidLine))
_minimap_painter.setOpacity(1)
_minimap_painter.drawPoint(_x, _y)
for _astroid in _model_asteroids:
_w = _astroid.radius * _w_ratio
if _w < 5:
_w = 5
_pen = QPen(QColor('#ffb86c'), _w, Qt.SolidLine)
_pen.setCapStyle(Qt.RoundCap)
_minimap_painter.setPen(_pen)
_x, _y = int(
_astroid.x * _w_ratio) + _pixmap_minimap.width() // 2, int(
_astroid.y * _h_ratio) + _pixmap_minimap.height() // 2
_minimap_painter.drawPoint(_x, _y)
for _bolt in _model_bolts:
_w = _bolt.radius * _w_ratio
if _w < 1:
_w = 1
_minimap_painter.setPen(QPen(QColor('#ff5555'), _w, Qt.SolidLine))
_x, _y = int(
_bolt.x * _w_ratio) + _pixmap_minimap.width() // 2, int(
_bolt.y * _h_ratio) + _pixmap_minimap.height() // 2
_minimap_painter.drawPoint(_x, _y)
_xy.setX(_xy.x() * _w_ratio + _pixmap_minimap.width() // 2)
_xy.setY(_xy.y() * _h_ratio + _pixmap_minimap.height() // 2)
_minimap_painter.setPen(QPen(QColor('#8be9fd'), 3, Qt.SolidLine))
_minimap_painter.drawEllipse(_xy, _dz_radius * _w_ratio,
_dz_radius * _h_ratio)
if not is_full:
_minimap_painter.setPen(QPen(QColor('#ffffff'), 1, Qt.SolidLine))
_x = -self.camera_pst.x() * _w_ratio + _pixmap_minimap.width() // 2
_y = self.camera_pst.y() * _h_ratio + _pixmap_minimap.height() // 2
_w = self.width() * _w_ratio
_h = self.height() * _h_ratio
_minimap_painter.drawRect(_x, _y - _h, _w, _h)
_minimap_painter.end()
_pixmap_minimap = _pixmap_minimap.transformed(QTransform().scale(
1, -1))
painter.setOpacity(1 if is_full else .75)
painter.drawPixmap(_p_origin, _pixmap_minimap)
def redraw(self):
self.graphics_scene.clear()
# draw screenshot
self.graphics_scene.addPixmap(self.screenPixel)
# prepare for drawing selected area
rect = QRectF(self.selected_area)
rect = rect.normalized()
top_left_point = rect.topLeft()
top_right_point = rect.topRight()
bottom_left_point = rect.bottomLeft()
bottom_right_point = rect.bottomRight()
top_middle_point = (top_left_point + top_right_point) / 2
left_middle_point = (top_left_point + bottom_left_point) / 2
bottom_middle_point = (bottom_left_point + bottom_right_point) / 2
right_middle_point = (top_right_point + bottom_right_point) / 2
# draw the picture mask
mask = QColor(0, 0, 0, 155)
if self.selected_area == QRect():
self.graphics_scene.addRect(0, 0, self.screenPixel.width(),
self.screenPixel.height(),
QPen(Qt.NoPen), mask)
else:
self.graphics_scene.addRect(0, 0, self.screenPixel.width(),
top_right_point.y(), QPen(Qt.NoPen),
mask)
self.graphics_scene.addRect(0, top_left_point.y(),
top_left_point.x(), rect.height(),
QPen(Qt.NoPen), mask)
self.graphics_scene.addRect(
top_right_point.x(), top_right_point.y(),
self.screenPixel.width() - top_right_point.x(), rect.height(),
QPen(Qt.NoPen), mask)
self.graphics_scene.addRect(
0, bottom_left_point.y(), self.screenPixel.width(),
self.screenPixel.height() - bottom_left_point.y(),
QPen(Qt.NoPen), mask)
# draw the toolBar
if self.action != ACTION_SELECT:
spacing = 5
# show the toolbar first, then move it to the correct position
# because the width of it may be wrong if this is the first time it shows
self.tooBar.show()
dest = QPointF(rect.bottomRight() -
QPointF(self.tooBar.width(), 0) -
QPointF(spacing, -spacing))
if dest.x() < spacing:
dest.setX(spacing)
pen_set_bar_height = self.penSetBar.height(
) if self.penSetBar is not None else 0
if dest.y() + self.tooBar.height(
) + pen_set_bar_height >= self.height():
if rect.top() - self.tooBar.height(
) - pen_set_bar_height < spacing:
dest.setY(rect.top() + spacing)
else:
dest.setY(rect.top() - self.tooBar.height() -
pen_set_bar_height - spacing)
self.tooBar.move(dest.toPoint())
if self.penSetBar is not None:
self.penSetBar.show()
self.penSetBar.move(dest.toPoint() +
QPoint(0,
self.tooBar.height() + spacing))
if self.action == ACTION_TEXT:
self.penSetBar.showFontWidget()
else:
self.penSetBar.showPenWidget()
else:
self.tooBar.hide()
if self.penSetBar is not None:
self.penSetBar.hide()
# draw the list
for step in self.drawListResult:
self.drawOneStep(step)
if self.drawListProcess is not None:
self.drawOneStep(self.drawListProcess)
if self.action != ACTION_TEXT:
self.drawListProcess = None
if self.selected_area != QRect():
self.items_to_remove = []
# draw the selected rectangle
pen = QPen(QColor(0, 255, 255), 2)
self.items_to_remove.append(self.graphics_scene.addRect(rect, pen))
# draw the drag point
radius = QPoint(3, 3)
brush = QBrush(QColor(0, 255, 255))
self.items_to_remove.append(
self.graphics_scene.addEllipse(
QRectF(top_left_point - radius, top_left_point + radius),
pen, brush))
self.items_to_remove.append(
self.graphics_scene.addEllipse(
QRectF(top_middle_point - radius,
top_middle_point + radius), pen, brush))
self.items_to_remove.append(
self.graphics_scene.addEllipse(
QRectF(top_right_point - radius, top_right_point + radius),
pen, brush))
self.items_to_remove.append(
self.graphics_scene.addEllipse(
QRectF(left_middle_point - radius,
left_middle_point + radius), pen, brush))
self.items_to_remove.append(
self.graphics_scene.addEllipse(
QRectF(right_middle_point - radius,
right_middle_point + radius), pen, brush))
self.items_to_remove.append(
self.graphics_scene.addEllipse(
QRectF(bottom_left_point - radius,
bottom_left_point + radius), pen, brush))
self.items_to_remove.append(
self.graphics_scene.addEllipse(
QRectF(bottom_middle_point - radius,
bottom_middle_point + radius), pen, brush))
self.items_to_remove.append(
self.graphics_scene.addEllipse(
QRectF(bottom_right_point - radius,
bottom_right_point + radius), pen, brush))
# draw the textedit
if self.textPosition is not None:
textSpacing = 50
position = QPoint()
if self.textPosition.x() + self.textInput.width(
) >= self.screenPixel.width():
position.setX(self.textPosition.x() - self.textInput.width())
else:
position.setX(self.textPosition.x())
if self.textRect is not None:
if self.textPosition.y() + self.textInput.height(
) + self.textRect.height() >= self.screenPixel.height():
position.setY(self.textPosition.y() -
self.textInput.height() -
self.textRect.height())
else:
position.setY(self.textPosition.y() +
self.textRect.height())
else:
if self.textPosition.y() + self.textInput.height(
) >= self.screenPixel.height():
position.setY(self.textPosition.y() -
self.textInput.height())
else:
position.setY(self.textPosition.y())
self.textInput.move(position)
self.textInput.show()
# self.textInput.getFocus()
# draw the magnifier
if self.action == ACTION_SELECT:
self.drawMagnifier()
if self.mousePressed:
self.drawSizeInfo()
if self.action == ACTION_MOVE_SELECTED:
self.drawSizeInfo()
