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 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 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 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 _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()