def _drag_pixmap(self, item, items):
"""
Internal function that shows the pixmap for the given item during drag operation
:param item: LibraryItem
:param items: list(LibraryItem)
:return: QPixmap
"""
rect = self.visualRect(self.index_from_item(item))
pixmap = QPixmap()
pixmap = pixmap.grabWidget(self, rect)
if len(items) > 1:
custom_width = 35
custom_padding = 5
custom_text = str(len(items))
custom_x = pixmap.rect().center().x() - float(custom_width * 0.5)
custom_y = pixmap.rect().top() + custom_padding
custom_rect = QRect(custom_x, custom_y, custom_width, custom_width)
painter = QPainter(pixmap)
painter.setRenderHint(QPainter.Antialiasing)
painter.setPen(Qt.NoPen)
painter.setBrush(self.viewer().background_selected_color())
painter.drawEllipse(custom_rect.center(),
float(custom_width * 0.5),
float(custom_width * 0.5))
font = QFont('Serif', 12, QFont.Light)
painter.setFont(font)
painter.setPen(self.viewer().text_selected_color())
painter.drawText(custom_rect, Qt.AlignCenter, str(custom_text))
return pixmap
def cdMapper(self,*args):
global cdR, cdG, cdB
temp2 = QPixmap(cd_pix2)
mask = QPixmap(cd_pix2_alpha)
mult = 255
R = cdR * mult
G = cdG *mult
B = cdB * mult
colour = QColor(R,G,B)
#print("R:" + str(cdR) + " G:" + str(cdG) + " B:" + str(cdB))
#Paint Lines
painter2 = QPainter(temp2)
painter2.setCompositionMode(painter2.CompositionMode_Overlay)
painter2.fillRect(temp2.rect(), colour)
painter2.end()
#Update Image
self.main_widget.lbl_LGTC_PRV.setPixmap(temp2)
def create_drop_indicator_pixmap(palette, size, drop_area):
border_color = palette.color(QPalette.Active, QPalette.Highlight)
background_color = palette.color(QPalette.Active, QPalette.Base)
area_background_color = palette.color(QPalette.Active,
QPalette.Highlight).lighter(150)
pm = QPixmap(size.width(), size.height())
pm.fill(QColor(0, 0, 0, 0))
painter = QPainter(pm)
pen = painter.pen()
base_rect = QRectF(pm.rect())
painter.fillRect(base_rect, background_color)
painter.save()
area_rect = QRectF()
area_line = QLineF()
gradient = QLinearGradient()
if drop_area == DropArea.TopDropArea:
area_rect = QRectF(base_rect.x(), base_rect.y(), base_rect.width(),
base_rect.height() * 0.5)
area_line = QLineF(area_rect.bottomLeft(), area_rect.bottomRight())
gradient.setStart(area_rect.topLeft())
gradient.setFinalStop(area_rect.bottomLeft())
gradient.setColorAt(0, area_background_color)
gradient.setColorAt(1, area_background_color.lighter(120))
elif drop_area == DropArea.RightDropArea:
area_rect = QRectF(base_rect.width() * 0.5, base_rect.y(),
base_rect.width() * 0.5, base_rect.height())
area_line = QLineF(area_rect.topLeft(), area_rect.bottomLeft())
gradient.setStart(area_rect.topLeft())
gradient.setFinalStop(area_rect.topRight())
gradient.setColorAt(0, area_background_color.lighter(120))
gradient.setColorAt(1, area_background_color)
elif drop_area == DropArea.BottomDropArea:
area_rect = QRectF(base_rect.x(),
base_rect.height() * 0.5, base_rect.width(),
base_rect.height() * 0.5)
area_line = QLineF(area_rect.topLeft(), area_rect.topRight())
gradient.setStart(area_rect.topLeft())
gradient.setFinalStop(area_rect.bottomLeft())
gradient.setColorAt(0, area_background_color.lighter(120))
gradient.setColorAt(1, area_background_color)
elif drop_area == DropArea.LeftDropArea:
area_rect = QRectF(base_rect.x(), base_rect.y(),
base_rect.width() * 0.5, base_rect.height())
area_line = QLineF(area_rect.topRight(), area_rect.bottomRight())
gradient.setStart(area_rect.topLeft())
gradient.setFinalStop(area_rect.topRight())
gradient.setColorAt(0, area_background_color)
gradient.setColorAt(1, area_background_color.lighter(120))
if area_rect.isValid():
painter.fillRect(area_rect, gradient)
pen = painter.pen()
pen.setColor(border_color)
pen.setStyle(Qt.DashLine)
painter.setPen(pen)
painter.drawLine(area_line)
painter.restore()
painter.save()
pen = painter.pen()
pen.setColor(border_color)
pen.setWidth(1)
painter.setPen(pen)
painter.drawRect(base_rect.adjusted(0, 0, -pen.width(), -pen.width()))
painter.restore()
return pm
class LightMaps(QWidget):
def __init__(self, parent: QWidget = None) -> None:
super().__init__(parent)
self.m_normalMap = SlippyMap(self)
self.m_largeMap = SlippyMap(self)
self.m_normalMap.updated.connect(self.updateMap)
self.m_largeMap.updated.connect(self.update)
self.pressed = False
self.snapped = False
self.pressPos = QPoint()
self.dragPos = QPoint()
self.tapTimer = QBasicTimer()
self.zoomed = False
self.zoomPixmap = QPixmap()
self.maskPixmap = QPixmap()
self.invert = False
def setCenter(self, lat: float, lng: float):
self.m_normalMap.latitude = lat
self.m_normalMap.longitude = lng
self.m_normalMap.invalidate()
self.m_largeMap.latitude = lat
self.m_largeMap.longitude = lng
self.m_largeMap.invalidate()
@Slot()
def toggleNightMode(self) -> None:
self.invert = not self.invert
self.update()
def activateZoom(self) -> None:
self.zoomed = True
self.tapTimer.stop()
self.m_largeMap.zoom = self.m_normalMap.zoom + 1
self.m_largeMap.width = self.m_normalMap.width * 2
self.m_largeMap.height = self.m_normalMap.height * 2
self.m_largeMap.latitude = self.m_normalMap.latitude
self.m_largeMap.longitude = self.m_normalMap.longitude
self.m_largeMap.invalidate()
self.update()
def resizeEvent(self, event: QResizeEvent) -> None:
self.m_normalMap.width = self.width()
self.m_normalMap.height = self.height()
self.m_normalMap.invalidate()
self.m_largeMap.width = self.m_normalMap.width * 2
self.m_largeMap.height = self.m_normalMap.height * 2
self.m_largeMap.invalidate()
def paintEvent(self, event: QPaintEvent) -> None:
p = QPainter(self)
self.m_normalMap.render(p, event.rect())
p.setPen(Qt.black)
p.drawText(
self.rect(),
Qt.AlignBottom | Qt.TextWordWrap,
"Map data CCBYSA 2009 OpenStreetMap.org contributors",
)
p.end()
if self.zoomed:
dim = min(self.width(), self.height())
magnifierSize = min(MAX_MAGNIFIER, dim * 2 / 3)
radius = magnifierSize / 2
ring = radius - 15
box = QSize(magnifierSize, magnifierSize)
if self.maskPixmap.size() != box:
self.maskPixmap = QPixmap(box)
self.maskPixmap.fill(Qt.transparent)
g = QRadialGradient()
g.setCenter(radius, radius)
g.setFocalPoint(radius, radius)
g.setRadius(radius)
g.setColorAt(1.0, QColor(255, 255, 255, 0))
g.setColorAt(0.5, QColor(128, 128, 128, 255))
mask = QPainter(self.maskPixmap)
mask.setRenderHint(QPainter.Antialiasing)
mask.setCompositionMode(QPainter.CompositionMode_Source)
mask.setBrush(g)
mask.setPen(Qt.NoPen)
mask.drawRect(self.maskPixmap.rect())
mask.setBrush(QColor(Qt.transparent))
mask.drawEllipse(g.center(), ring, ring)
mask.end()
center = self.dragPos - QPoint(0, radius)
center = center + QPoint(0, radius / 2)
corner = center - QPoint(radius, radius)
xy = center * 2 - QPoint(radius, radius)
# only set the dimension to the magnified portion
if self.zoomPixmap.size() != box:
zoomPixmap = QPixmap(box)
zoomPixmap.fill(Qt.lightGray)
if True:
p = QPainter(zoomPixmap)
p.translate(-xy)
self.m_largeMap.render(p, QRect(xy, box))
p.end()
clipPath = QPainterPath()
clipPath.addEllipse(center, ring, ring)
p = QPainter(self)
p.setRenderHint(QPainter.Antialiasing)
p.setClipPath(clipPath)
p.drawPixmap(corner, zoomPixmap)
p.setClipping(False)
p.drawPixmap(corner, self.maskPixmap)
p.setPen(Qt.gray)
p.drawPath(clipPath)
if self.invert:
p = QPainter(self)
p.setCompositionMode(QPainter.CompositionMode_Difference)
p.fillRect(event.rect(), Qt.white)
p.end()
def timerEvent(self, event: QTimerEvent) -> None:
if not self.zoomed:
self.activateZoom()
self.update()
def mousePressEvent(self, event: QMouseEvent) -> None:
if event.buttons() != Qt.LeftButton:
return
self.pressed = self.snapped = True
self.pressPos = self.dragPos = event.pos()
self.tapTimer.stop()
self.tapTimer.start(HOLD_TIME, self)
def mouseMoveEvent(self, event: QMouseEvent) -> None:
if not event.buttons():
return
if not self.zoomed:
if not self.pressed or not self.snapped:
delta = event.pos() - self.pressPos
self.pressPos = event.pos()
self.m_normalMap.pan(delta)
return
else:
threshold = 10
delta = event.pos() - self.pressPos
if self.snapped:
self.snapped &= delta.x() < threshold
self.snapped &= delta.y() < threshold
self.snapped &= delta.x() > -threshold
self.snapped &= delta.y() > -threshold
if not self.snapped:
self.tapTimer.stop()
else:
self.dragPos = event.pos()
self.update()
def mouseReleaseEvent(self, event: QMouseEvent) -> None:
self.zoomed = False
self.update()
def keyPressEvent(self, event: QKeyEvent) -> None:
if not self.zoomed:
if event.key() == Qt.Key_Left:
self.m_normalMap.pan(QPoint(20, 0))
if event.key() == Qt.Key_Right:
self.m_normalMap.pan(QPoint(-20, 0))
if event.key() == Qt.Key_Up:
self.m_normalMap.pan(QPoint(0, 20))
if event.key() == Qt.Key_Down:
self.m_normalMap.pan(QPoint(0, -20))
if event.key() == Qt.Key_Z or event.key() == Qt.Key_Select:
self.dragPos = QPoint(self.width() / 2, self.height() / 2)
self.activateZoom()
else:
if event.key() == Qt.Key_Z or event.key() == Qt.Key_Select:
self.zoomed = False
self.update()
delta = QPoint(0, 0)
if event.key() == Qt.Key_Left:
delta = QPoint(-15, 0)
if event.key() == Qt.Key_Right:
delta = QPoint(15, 0)
if event.key() == Qt.Key_Up:
delta = QPoint(0, -15)
if event.key() == Qt.Key_Down:
delta = QPoint(0, 15)
if delta != QPoint(0, 0):
self.dragPos += delta
self.update()
@Slot(QRect)
def updateMap(self, r):
self.update(r)