class Compass(QWidget):
def __init__(self, parent):
super().__init__(parent)
self.uas = None
svgRenderer = QSvgRenderer('res/compass.svg')
self.compass = QGraphicsSvgItem()
self.compass.setSharedRenderer(svgRenderer)
self.compass.setCacheMode(QGraphicsItem.NoCache)
self.compass.setElementId('needle')
center = self.compass.boundingRect().center()
self.compass.setTransformOriginPoint(center.x(), center.y())
bkgnd = QGraphicsSvgItem()
bkgnd.setSharedRenderer(svgRenderer)
bkgnd.setCacheMode(QGraphicsItem.NoCache)
bkgnd.setElementId('background')
self.compass.setPos(
bkgnd.boundingRect().width() / 2 -
self.compass.boundingRect().width() / 2,
bkgnd.boundingRect().height() / 2 -
self.compass.boundingRect().height() / 2)
self.compass.setTransformOriginPoint(
self.compass.boundingRect().width() / 2,
self.compass.boundingRect().height() / 2)
fregnd = QGraphicsSvgItem()
fregnd.setSharedRenderer(svgRenderer)
fregnd.setCacheMode(QGraphicsItem.NoCache)
fregnd.setElementId('foreground')
scene = QGraphicsScene()
scene.addItem(bkgnd)
scene.addItem(self.compass)
scene.addItem(fregnd)
scene.setSceneRect(bkgnd.boundingRect())
view = QGraphicsView(scene)
view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
layout = QVBoxLayout()
layout.addWidget(view)
super().setLayout(layout)
def setHeading(self, hdr):
if math.isnan(hdr) == False:
hdr *= 180.0 / math.pi
self.compass.setRotation(360.0 - hdr)
def updateAttitude(self, sourceUAS, timestamp, roll, pitch, yaw):
unused(sourceUAS, timestamp, roll, pitch)
self.setHeading(yaw)
def setActiveUAS(self, uas):
uas.updateAttitudeSignal.connect(self.updateAttitude)
self.uas = uas
def __init__(self, parent):
super().__init__(parent)
self.uas = None
svgRenderer = QSvgRenderer('res/barometer.svg')
bkgnd = QGraphicsSvgItem()
bkgnd.setSharedRenderer(svgRenderer)
bkgnd.setCacheMode(QGraphicsItem.NoCache)
bkgnd.setElementId('background')
scene = QGraphicsScene()
scene.addItem(bkgnd)
scene.setSceneRect(bkgnd.boundingRect())
self.needle = QGraphicsSvgItem()
self.needle.setSharedRenderer(svgRenderer)
self.needle.setCacheMode(QGraphicsItem.NoCache)
self.needle.setElementId('needle')
self.needle.setParentItem(bkgnd)
self.needle.setPos(
bkgnd.boundingRect().width() / 2 -
self.needle.boundingRect().width() / 2,
bkgnd.boundingRect().height() / 2 -
self.needle.boundingRect().height() / 2)
self.needle.setTransformOriginPoint(
self.needle.boundingRect().width() / 2,
self.needle.boundingRect().height() / 2)
# textElement = svgRenderer.boundsOnElement('needle-text')
self.digitalBaro = QGraphicsTextItem()
self.digitalBaro.setDefaultTextColor(QColor(255, 255, 255))
self.digitalBaro.document().setDefaultTextOption(
QTextOption(Qt.AlignCenter))
self.digitalBaro.setFont(QFont('monospace', 13, 60))
self.digitalBaro.setParentItem(bkgnd)
txm = QTransform()
txm.translate(
bkgnd.boundingRect().center().x(),
bkgnd.boundingRect().height() -
1.5 * self.digitalBaro.document().size().height())
self.digitalBaro.setTransform(txm, False)
view = QGraphicsView(scene)
view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
layout = QVBoxLayout()
layout.addWidget(view)
self.setLayout(layout)
self.setBarometer(1000)
def __init__(self, parent):
super().__init__(parent)
self.uas = None
svgRenderer = QSvgRenderer('res/compass.svg')
self.compass = QGraphicsSvgItem()
self.compass.setSharedRenderer(svgRenderer)
self.compass.setCacheMode(QGraphicsItem.NoCache)
self.compass.setElementId('needle')
center = self.compass.boundingRect().center()
self.compass.setTransformOriginPoint(center.x(), center.y())
bkgnd = QGraphicsSvgItem()
bkgnd.setSharedRenderer(svgRenderer)
bkgnd.setCacheMode(QGraphicsItem.NoCache)
bkgnd.setElementId('background')
self.compass.setPos(
bkgnd.boundingRect().width() / 2 -
self.compass.boundingRect().width() / 2,
bkgnd.boundingRect().height() / 2 -
self.compass.boundingRect().height() / 2)
self.compass.setTransformOriginPoint(
self.compass.boundingRect().width() / 2,
self.compass.boundingRect().height() / 2)
fregnd = QGraphicsSvgItem()
fregnd.setSharedRenderer(svgRenderer)
fregnd.setCacheMode(QGraphicsItem.NoCache)
fregnd.setElementId('foreground')
scene = QGraphicsScene()
scene.addItem(bkgnd)
scene.addItem(self.compass)
scene.addItem(fregnd)
scene.setSceneRect(bkgnd.boundingRect())
view = QGraphicsView(scene)
view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
layout = QVBoxLayout()
layout.addWidget(view)
super().setLayout(layout)
class Vectorgraphic(DesignItem):
def __init__(self, filename, scene):
super(Vectorgraphic, self).__init__(scene)
self.renderer = QSvgRenderer()
self.renderer.load(filename)
self.svg = QGraphicsSvgItem(self)
self.svg.setSharedRenderer(self.renderer)
self.setRect(0, 0,
self.svg.boundingRect().width(),
self.svg.boundingRect().height())
def typeName(self):
return "Vectorgraphic"
def paint(self, paint, option, widget):
if option.state & QStyle.State_Selected:
self.drawHighlightSelected(paint, option)
def scaleObjects(self):
self.xscale = self.rect.width() / self.svg.boundingRect().width()
self.yscale = self.rect.height() / self.svg.boundingRect().height()
trans = QTransform()
trans.scale(self.xscale, self.yscale)
self.svg.setTransform(trans)
def setScale(self, x, y):
self.xscale = x
self.yscale = y
trans = QTransform()
trans.scale(self.xscale, self.yscale)
self.svg.setTransform(trans)
self.setRect(0, 0,
self.svg.boundingRect().width() * x,
self.svg.boundingRect().height() * y)
class SvgView(QGraphicsView):
Native, OpenGL, Image = range(3)
def __init__(self, parent=None):
super(SvgView, self).__init__(parent)
self.renderer = SvgView.Native
self.svgItem = None
self.backgroundItem = None
self.outlineItem = None
self.image = QImage()
self.setScene(QGraphicsScene(self))
self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
self.setDragMode(QGraphicsView.ScrollHandDrag)
self.setViewportUpdateMode(QGraphicsView.FullViewportUpdate)
# Prepare background check-board pattern.
tilePixmap = QPixmap(64, 64)
tilePixmap.fill(Qt.white)
tilePainter = QPainter(tilePixmap)
color = QColor(220, 220, 220)
tilePainter.fillRect(0, 0, 32, 32, color)
tilePainter.fillRect(32, 32, 32, 32, color)
tilePainter.end()
self.setBackgroundBrush(QBrush(tilePixmap))
def drawBackground(self, p, rect):
p.save()
p.resetTransform()
p.drawTiledPixmap(self.viewport().rect(),
self.backgroundBrush().texture())
p.restore()
def openFile(self, svg_file):
if not svg_file.exists():
return
s = self.scene()
if self.backgroundItem:
drawBackground = self.backgroundItem.isVisible()
else:
drawBackground = False
if self.outlineItem:
drawOutline = self.outlineItem.isVisible()
else:
drawOutline = True
s.clear()
self.resetTransform()
self.svgItem = QGraphicsSvgItem(svg_file.fileName())
self.svgItem.setFlags(QGraphicsItem.ItemClipsToShape)
self.svgItem.setCacheMode(QGraphicsItem.NoCache)
self.svgItem.setZValue(0)
self.backgroundItem = QGraphicsRectItem(self.svgItem.boundingRect())
self.backgroundItem.setBrush(Qt.white)
self.backgroundItem.setPen(QPen(Qt.NoPen))
self.backgroundItem.setVisible(drawBackground)
self.backgroundItem.setZValue(-1)
self.outlineItem = QGraphicsRectItem(self.svgItem.boundingRect())
outline = QPen(Qt.black, 2, Qt.DashLine)
outline.setCosmetic(True)
self.outlineItem.setPen(outline)
self.outlineItem.setBrush(QBrush(Qt.NoBrush))
self.outlineItem.setVisible(drawOutline)
self.outlineItem.setZValue(1)
s.addItem(self.backgroundItem)
s.addItem(self.svgItem)
s.addItem(self.outlineItem)
s.setSceneRect(self.outlineItem.boundingRect().adjusted(
-10, -10, 10, 10))
def setRenderer(self, renderer):
self.renderer = renderer
if self.renderer == SvgView.OpenGL:
if QGLFormat.hasOpenGL():
self.setViewport(QGLWidget(QGLFormat(QGL.SampleBuffers)))
else:
self.setViewport(QWidget())
def setHighQualityAntialiasing(self, highQualityAntialiasing):
if QGLFormat.hasOpenGL():
self.setRenderHint(QPainter.HighQualityAntialiasing,
highQualityAntialiasing)
def setViewBackground(self, enable):
if self.backgroundItem:
self.backgroundItem.setVisible(enable)
def setViewOutline(self, enable):
if self.outlineItem:
self.outlineItem.setVisible(enable)
def paintEvent(self, event):
if self.renderer == SvgView.Image:
if self.image.size() != self.viewport().size():
self.image = QImage(self.viewport().size(),
QImage.Format_ARGB32_Premultiplied)
imagePainter = QPainter(self.image)
QGraphicsView.render(self, imagePainter)
imagePainter.end()
p = QPainter(self.viewport())
p.drawImage(0, 0, self.image)
else:
super(SvgView, self).paintEvent(event)
def wheelEvent(self, event):
factor = pow(1.2, event.delta() / 240.0)
self.scale(factor, factor)
event.accept()
class ShapeDialog(QDialog):
"""
The main dialog box for the custom symbol window.
"""
def __init__(self, parent=None):
super(ShapeDialog, self).__init__(parent)
self.resize(500, 300) # resize to a fixed dim
self.setWindowTitle("Add New Shapes")
self.createLayout()
self.graphic = None
def createLayout(self):
#build layout for the dialog box
importButton = QPushButton("Import", self)
importButton.clicked.connect(self.importSVG)
saveButton = QPushButton("Save", self)
saveButton.clicked.connect(self.saveEvent)
self.symbolName = QLineEdit(self)
self.symbolName.setPlaceholderText("Enter Symbol Name")
symbolNameLabel = QLabel("Symbol Name")
symbolNameLabel.setBuddy(self.symbolName)
self.symbolClass = QLineEdit(self)
self.symbolClass.setPlaceholderText("Enter Symbol Class Name")
symbolClassLabel = QLabel("Symbol Class Name")
symbolClassLabel.setBuddy(self.symbolClass)
self.symbolCategory = QLineEdit(self)
self.symbolCategory.setPlaceholderText("Enter Symbol Category")
symbolCategoryLabel = QLabel("Symbol Category")
symbolCategoryLabel.setBuddy(self.symbolCategory)
addGripItem = QPushButton("Add Grip Item", self)
addGripItem.clicked.connect(self.addGrip)
addLineGripItem = QPushButton("Add Line Grip Item", self)
addLineGripItem.clicked.connect(self.addLineGrip)
self.painter = QGraphicsScene()
view = QGraphicsView(self.painter)
layout = QGridLayout(self)
subLayout = QBoxLayout(QBoxLayout.LeftToRight)
subLayout.addWidget(importButton)
subLayout.addWidget(saveButton)
subLayout.addStretch(1)
layout.addLayout(subLayout, 0, 0, 1, -1)
subLayout2 = QBoxLayout(QBoxLayout.LeftToRight)
subLayout2.addWidget(view, stretch=1)
subLayout3 = QBoxLayout(QBoxLayout.TopToBottom)
subLayout3.addWidget(symbolNameLabel)
subLayout3.addWidget(self.symbolName)
subLayout3.addWidget(symbolClassLabel)
subLayout3.addWidget(self.symbolClass)
subLayout3.addWidget(symbolCategoryLabel)
subLayout3.addWidget(self.symbolCategory)
subLayout3.addStretch(1)
subLayout3.addWidget(addGripItem)
subLayout3.addWidget(addLineGripItem)
subLayout2.addLayout(subLayout3)
layout.addLayout(subLayout2, 1, 0, -1, -1)
self.setLayout(layout)
def importSVG(self):
# Imports svg file through user input, adds it to the scene and stores it as a reference
self.name = QFileDialog.getOpenFileName(self, 'Open SVG File', '', 'Scalable Vector Graphics (*svg)')
if self.name:
self.graphic = QGraphicsSvgItem(self.name[0])
self.graphic.setZValue(-1)
self.painter.addItem(self.graphic)
def saveEvent(self):
# executes the build procedure
#check if all necessary values are there, each is seperate to show qalerts later on
if self.graphic is None:
return
itemName = self.symbolName.text()
if itemName is '':
return
className = self.symbolClass.text()
if className is '':
return
category = self.symbolCategory.text()
if category == "":
category = "misc"
# get rect for calculating grip positions
graphicRect = self.graphic.boundingRect()
#save file
name = QFileDialog.getSaveFileName(self, 'Save Icon', className, 'PNG (*.png)')
if name:
QIcon(self.name[0]).pixmap(QSize(64, 64)).toImage().save(name[0])
else:
return
#calculate grip positions and build a list
gripList = []
x, y, w, h = graphicRect.getRect()
for i in self.grips:
pos = i.pos()
entry = [abs((x-pos.x())/w)*100, abs((y-pos.y())/h)*100, i.location]
if isinstance(i, gripRect):
if i.location in ["top", "bottom"]:
entry.append(i.height)
else:
entry.append(i.width)
gripList.append(entry)
# format list in class definition flavor
grips = ",\n ".join([str(i) for i in gripList]) if gripList else ""
if grips:
grips = "self.grips = [" + grips + "]\n"
# build output dialog box
temp = QDialog(self)
tempLayout = QBoxLayout(QBoxLayout.TopToBottom)
output = OutputBox(temp, f"""
<b> Class Definition:</b>
<pre>
class {className}(NodeItem):
def __init__(self):
super({className}, self).__init__("svg/{category}/{str.split(name[0], "/")[-1][:-4]}")
{grips}
</pre>
<b> Items.json entry:</b>
<pre>
"{category}": {{
"{itemName}": {{
"name": "{itemName}",
"icon": ".\\{category}\\{str.split(name[0], "/")[-1]}",
"class": "{category}",
"object": "{className}",
"args": []
}}
}}</pre>""")
tempLayout.addWidget(output)
temp.setLayout(tempLayout)
temp.exec()
@property
def grips(self):
return [i for i in self.painter.items() if isinstance(i, gripAbstract)]
def addGrip(self):
#adds a grip dot to the scene
grip = gripDot()
self.painter.addItem(grip)
def addLineGrip(self):
#adds a line grip item
rect = gripRect()
self.painter.addItem(rect)
class SvgView(QGraphicsView):
Native, Image = range(2)
clicked_event = pyqtSignal(QMouseEvent)
double_click_event = pyqtSignal(QMouseEvent)
wheel_event = pyqtSignal(QWheelEvent)
def __init__(self, parent=None):
super(SvgView, self).__init__(parent)
self.renderer = SvgView.Native
self.svgItem = None
self.backgroundItem = None
self.image = QImage()
self.default_width = 0
self.default_height = 0
self.__tf_rotate = QTransform()
self.__tf_scale = QTransform()
self.setScene(QGraphicsScene(self))
def drawBackground(self, p: QPainter, rect: QRectF):
p.save()
p.resetTransform()
p.drawTiledPixmap(self.viewport().rect(),
self.backgroundBrush().texture())
p.restore()
def openFile(self, svg_file: QFile):
if not svg_file.exists():
return
if self.backgroundItem:
drawBackground = self.backgroundItem.isVisible()
else:
drawBackground = False
s = self.scene()
s.clear()
self.resetTransform()
self.svgItem = QGraphicsSvgItem(svg_file.fileName())
self.svgItem.setFlags(QGraphicsItem.ItemClipsToShape)
self.svgItem.setCacheMode(QGraphicsItem.NoCache)
self.svgItem.setZValue(0)
tmp = self.svgItem.renderer().defaultSize()
self.default_width = tmp.width()
self.default_height = tmp.height()
self.backgroundItem = QGraphicsRectItem(self.svgItem.boundingRect())
self.backgroundItem.setBrush(Qt.white)
self.backgroundItem.setPen(QPen(Qt.NoPen))
self.backgroundItem.setVisible(drawBackground)
self.backgroundItem.setZValue(-1)
s.addItem(self.backgroundItem)
s.addItem(self.svgItem)
def setRenderer(self, renderer):
self.renderer = renderer
self.setViewport(QWidget())
def setViewBackground(self, enable):
if self.backgroundItem:
self.backgroundItem.setVisible(enable)
def paintEvent(self, event: QPaintEvent):
if self.renderer == SvgView.Image:
if self.image.size() != self.viewport().size():
self.image = QImage(self.viewport().size(),
QImage.Format_ARGB32_Premultiplied)
imagePainter = QPainter(self.image)
QGraphicsView.render(self, imagePainter)
imagePainter.end()
p = QPainter(self.viewport())
p.drawImage(0, 0, self.image)
else:
super(SvgView, self).paintEvent(event)
def _setSize(self, width: float, height: float):
self.__tf_scale = QTransform.fromScale(width / self.default_width,
height / self.default_height)
self.__tf()
def _setAngle(self, angle: float):
self.__tf_rotate = QTransform().rotate(angle)
self.__tf()
def __tf(self):
self.setTransform(self.__tf_rotate * self.__tf_scale)
def mouseReleaseEvent(self, event: QMouseEvent):
self.clicked_event.emit(event)
def mouseDoubleClickEvent(self, event: QMouseEvent):
self.double_click_event.emit(event)
def wheelEvent(self, event: QWheelEvent):
self.wheel_event.emit(event)
class SvgView(QGraphicsView):
Native, OpenGL, Image = range(3)
def __init__(self, parent=None):
super(SvgView, self).__init__(parent)
self.renderer = SvgView.Native
self.svgItem = None
self.backgroundItem = None
self.outlineItem = None
self.image = QImage()
self.setScene(QGraphicsScene(self))
self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
self.setDragMode(QGraphicsView.ScrollHandDrag)
self.setViewportUpdateMode(QGraphicsView.FullViewportUpdate)
# Prepare background check-board pattern.
tilePixmap = QPixmap(64, 64)
tilePixmap.fill(Qt.white)
tilePainter = QPainter(tilePixmap)
color = QColor(220, 220, 220)
tilePainter.fillRect(0, 0, 32, 32, color)
tilePainter.fillRect(32, 32, 32, 32, color)
tilePainter.end()
self.setBackgroundBrush(QBrush(tilePixmap))
def drawBackground(self, p, rect):
p.save()
p.resetTransform()
p.drawTiledPixmap(self.viewport().rect(),
self.backgroundBrush().texture())
p.restore()
def openFile(self, svg_file):
if not svg_file.exists():
return
s = self.scene()
if self.backgroundItem:
drawBackground = self.backgroundItem.isVisible()
else:
drawBackground = False
if self.outlineItem:
drawOutline = self.outlineItem.isVisible()
else:
drawOutline = True
s.clear()
self.resetTransform()
self.svgItem = QGraphicsSvgItem(svg_file.fileName())
self.svgItem.setFlags(QGraphicsItem.ItemClipsToShape)
self.svgItem.setCacheMode(QGraphicsItem.NoCache)
self.svgItem.setZValue(0)
self.backgroundItem = QGraphicsRectItem(self.svgItem.boundingRect())
self.backgroundItem.setBrush(Qt.white)
self.backgroundItem.setPen(QPen(Qt.NoPen))
self.backgroundItem.setVisible(drawBackground)
self.backgroundItem.setZValue(-1)
self.outlineItem = QGraphicsRectItem(self.svgItem.boundingRect())
outline = QPen(Qt.black, 2, Qt.DashLine)
outline.setCosmetic(True)
self.outlineItem.setPen(outline)
self.outlineItem.setBrush(QBrush(Qt.NoBrush))
self.outlineItem.setVisible(drawOutline)
self.outlineItem.setZValue(1)
s.addItem(self.backgroundItem)
s.addItem(self.svgItem)
s.addItem(self.outlineItem)
s.setSceneRect(self.outlineItem.boundingRect().adjusted(-10, -10, 10, 10))
def setRenderer(self, renderer):
self.renderer = renderer
if self.renderer == SvgView.OpenGL:
if QGLFormat.hasOpenGL():
self.setViewport(QGLWidget(QGLFormat(QGL.SampleBuffers)))
else:
self.setViewport(QWidget())
def setHighQualityAntialiasing(self, highQualityAntialiasing):
if QGLFormat.hasOpenGL():
self.setRenderHint(QPainter.HighQualityAntialiasing,
highQualityAntialiasing)
def setViewBackground(self, enable):
if self.backgroundItem:
self.backgroundItem.setVisible(enable)
def setViewOutline(self, enable):
if self.outlineItem:
self.outlineItem.setVisible(enable)
def paintEvent(self, event):
if self.renderer == SvgView.Image:
if self.image.size() != self.viewport().size():
self.image = QImage(self.viewport().size(),
QImage.Format_ARGB32_Premultiplied)
imagePainter = QPainter(self.image)
QGraphicsView.render(self, imagePainter)
imagePainter.end()
p = QPainter(self.viewport())
p.drawImage(0, 0, self.image)
else:
super(SvgView, self).paintEvent(event)
def wheelEvent(self, event):
print(event.angleDelta().y())
factor = pow(1.2, event.angleDelta().y() / 240.0)
self.scale(factor, factor)
event.accept()
class svg_size(QDialog):
def showEvent(self, event):
#self.grview.fitInView(self.scene.sceneRect(), Qt.KeepAspectRatio)
pass
def standard_size(self):
# size in sqares times squaresize, minus distance from square borders
w = self.ui.spin_width.value() * self.squaresize - 10
h = self.ui.spin_height.value() * self.squaresize - 10
standard_size = QRectF(0, 0, w, h)
start_pos = QPointF(self.startpos + 5, self.startpos + 5)
self.start_bounding_rect = QRectF(self.startpos + 5, self.startpos + 5,
w, h)
self.accept_rect(standard_size, start_pos)
self.user_rect.setRect(self.start_bounding_rect)
def __init__(self,
parent=None,
original_path=None,
icon_path=None,
xmax=1100,
ymax=1100,
squaresize=100):
super(svg_size, self).__init__(parent)
# boilerplate initialization
self.xmax = xmax
self.ymax = ymax
self.squaresize = squaresize
self.ui = size_gui()
self.ui.setupUi(self)
self.startpos = 5 * self.squaresize
self.icon_path = Path(icon_path) if icon_path else None
self.original_path = Path(original_path) if original_path else None
self.outfilepath = None
# set up grahpicsView
self.grview = MyQGraphicsView(self)
self.grview.setGeometry(QRect(0, 0, 571, 571))
self.grview.setContextMenuPolicy(Qt.NoContextMenu)
self.grview.setFrameShadow(QFrame.Plain)
self.grview.setSizeAdjustPolicy(QAbstractScrollArea.AdjustIgnored)
self.grview.setObjectName("graphicsView")
#self.ui.graphicsView.wheelEvent = my_mouse_wheel_event
self.scene = myGraphicsScene(
) # use my own scene class with the added signal
self.scene.setSceneRect(0, 0, self.xmax, self.ymax)
# Paint the grid lines every 100 "svg_points"
for i in range(0, self.xmax + 1, self.squaresize):
self.line(i, hori=False)
for i in range(0, self.ymax + 1, self.squaresize):
self.line(i, hori=True)
# start rect and svg with some standard numbers
self.svg = QGraphicsSvgItem(str(icon_path))
self.user_rect = GraphicsRectItem(
QRectF(self.startpos + 5, self.startpos + 5, self.squaresize - 10,
self.squaresize - 10))
# add svg and rect to scene
self.scene.addItem(self.svg)
self.scene.addItem(self.user_rect)
# set sizes according to spinboxes
start_bounding_rect = self.standard_size()
# connect interactive elements
self.ui.spin_height.valueChanged.connect(self.standard_size)
self.ui.spin_width.valueChanged.connect(self.standard_size)
self.scene.rect_changed.connect(self.accept_rect)
# put the graphics on the screen and show
self.grview.setScene(self.scene)
#self.grview.fitInView(self.scene.sceneRect(), Qt.KeepAspectRatio)
self.grview.show()
def retranslateUI(self):
_translate = QtCore.QCoreApplication.translate
self.graphicsView.setToolTip(
_translate(
"dialog_symbol_sizing",
"After width and height are entered, do the last adjustments in this window"
))
def line(self, coord, hori=True):
if hori:
self.scene.addLine(0, coord, self.xmax, coord, QPen())
else:
self.scene.addLine(coord, 0, coord, self.ymax, QPen())
def accept_rect(self, rect, pos):
''' takes the new coordinates from the moved rectangle and applies them to the svg graphic'''
br = self.svg.boundingRect()
relative = min(br.width(), br.height())
rect_min = min(rect.width(), rect.height())
scale = rect_min / relative
self.svg.setScale(scale)
self.svg_scale = scale
pos_x = pos.x() + rect.x()
pos_y = pos.y() + rect.y()
self.svg.setX(pos_x)
self.svg.setY(pos_y)
self.svg_pos = (pos_x % self.squaresize, pos_y % self.squaresize)
class Barometer(QWidget):
def __init__(self, parent):
super().__init__(parent)
self.uas = None
svgRenderer = QSvgRenderer('res/barometer.svg')
bkgnd = QGraphicsSvgItem()
bkgnd.setSharedRenderer(svgRenderer)
bkgnd.setCacheMode(QGraphicsItem.NoCache)
bkgnd.setElementId('background')
scene = QGraphicsScene()
scene.addItem(bkgnd)
scene.setSceneRect(bkgnd.boundingRect())
self.needle = QGraphicsSvgItem()
self.needle.setSharedRenderer(svgRenderer)
self.needle.setCacheMode(QGraphicsItem.NoCache)
self.needle.setElementId('needle')
self.needle.setParentItem(bkgnd)
self.needle.setPos(
bkgnd.boundingRect().width() / 2 -
self.needle.boundingRect().width() / 2,
bkgnd.boundingRect().height() / 2 -
self.needle.boundingRect().height() / 2)
self.needle.setTransformOriginPoint(
self.needle.boundingRect().width() / 2,
self.needle.boundingRect().height() / 2)
# textElement = svgRenderer.boundsOnElement('needle-text')
self.digitalBaro = QGraphicsTextItem()
self.digitalBaro.setDefaultTextColor(QColor(255, 255, 255))
self.digitalBaro.document().setDefaultTextOption(
QTextOption(Qt.AlignCenter))
self.digitalBaro.setFont(QFont('monospace', 13, 60))
self.digitalBaro.setParentItem(bkgnd)
txm = QTransform()
txm.translate(
bkgnd.boundingRect().center().x(),
bkgnd.boundingRect().height() -
1.5 * self.digitalBaro.document().size().height())
self.digitalBaro.setTransform(txm, False)
view = QGraphicsView(scene)
view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
layout = QVBoxLayout()
layout.addWidget(view)
self.setLayout(layout)
self.setBarometer(1000)
def setBarometer(self, hbar):
deg = ((hbar - 950) * 3 + 210) % 360
self.needle.setRotation(deg)
self.digitalBaro.setPlainText('{:.1f}'.format(hbar))
self.digitalBaro.adjustSize()
self.digitalBaro.setX(0 - self.digitalBaro.textWidth() / 2)
def updateAirPressure(self, sourceUAS, timestamp, absPressure,
diffPressure, temperature):
unused(sourceUAS, timestamp, diffPressure, temperature)
self.setBarometer(absPressure)
def setActiveUAS(self, uas):
uas.updateAirPressureSignal.connect(self.updateAirPressure)
self.uas = uas
class Text(DesignItem):
def __init__(self, text, scene):
super(Text, self).__init__(scene)
self.font = QFont("Arial")
self.font.setPointSize(14)
self.font.setStyleName("Standard")
self.text = text
self.textcolor = QColor(Qt.black)
self.data = str.encode(self.getSvg())
self.renderer = QSvgRenderer()
self.renderer.load(self.data)
self.svg = QGraphicsSvgItem(self)
self.svg.setSharedRenderer(self.renderer)
self.setRect(0, 0,
self.svg.boundingRect().width(),
self.svg.boundingRect().height())
def typeName(self):
return "Text"
def paint(self, paint, option, widget):
if option.state & QStyle.State_Selected:
self.drawHighlightSelected(paint, option)
def getTextTag(self, id):
fm = QFontMetrics(self.font)
svg = "<text "
if id:
svg += "id=\"" + id + "\" "
svg += "x=\"0\" y=\"" + str(fm.ascent()) + "\" "
svg += "font-family=\"" + self.font.family() + "\" "
svg += "font-size=\"" + str(self.font.pointSize() * 1.25) + "px\" "
if self.font.bold():
svg += "font-weight=\"bold\" "
if self.font.italic():
svg += "font-style=\"italic\" "
svg += "fill=\"" + self.textcolor.name() + "\" "
svg += "opacity=\"" + str(self.opacity()) + "\" "
svg += ">"
svg += self.text
svg += "</text>"
return svg
def getSvg(self):
font = QFont(self.font.family())
font.setBold(self.font.bold())
font.setItalic(self.font.italic())
font.setPixelSize(self.font.pointSize() * 1.25)
fm = QFontMetrics(font)
self.width = fm.width(self.text) + 2
self.height = fm.height()
svg = "<svg width=\"" + str(self.width) + "\" "
svg += "height=\"" + str(self.height) + "\" >"
svg += self.getTextTag("")
svg += "</svg>"
return svg
def setScale(self, x, y):
self.xscale = x
self.yscale = y
trans = QTransform()
trans.scale(self.xscale, self.yscale)
self.svg.setTransform(trans)
self.setRect(0, 0,
self.svg.boundingRect().width() * x,
self.svg.boundingRect().height() * y)
def scaleObjects(self):
self.xscale = self.rect.width() / self.svg.boundingRect().width()
self.yscale = self.rect.height() / self.svg.boundingRect().height()
trans = QTransform()
trans.scale(self.xscale, self.yscale)
self.svg.setTransform(trans)
def _load_svg(self, path: str, reload_only: bool) -> None:
"""Load new vector graphic into the graphics scene."""
item = QGraphicsSvgItem(path)
self._update_scene(item, item.boundingRect(), reload_only)
