def paintEvent(self, pe) -> None:
if not self.inhibit_paint:
extent = 1.5 * np.pi
offset = 1.25 * np.pi
painter = QPainter(self)
# So that we can use the background color
painter.setBackgroundMode(Qt.OpaqueMode)
# Smooth out the circle
painter.setRenderHint(QPainter.Antialiasing)
# Use background color
bgColor = painter.background().color()
painter.setBrush(painter.background())
if self._text not in implementedKnobs:
painter.setBrush(QtGui.QBrush(QtGui.QColor(int("0xcccccc",
0))))
# Store color from stylesheet, pen will be overridden
pointColor = QColor(painter.pen().color())
# print(QDial.width(self), QDial.height(self))
# draw widget borders
pen = QPen(QColor(self._ringColor), 1)
pen.setCapStyle(Qt.SquareCap)
painter.setPen(pen)
# uncomment the following line to draw outer rect
# painter.drawRect(0, 0, np.floor(QDial.width(self)), QDial.height(self))
# No border
painter.setPen(QPen(Qt.NoPen))
# the heignt of the widget is 2*radius + 2*fontsize1 + 2*fontsize2
# where fontsize1 = .4radius and fontsize2 = .9*.4*radius
# so QDial.height = radius * (2+.4*2+.4*.9*2)
#
fontsize1factor = .4
fontsize2reduction = .9
fontsize2factor = fontsize1factor * fontsize2reduction
center_x = QDial.width(self) / 2.0
center_y = QDial.height(self) / 2.0
if not self._hasFixedSize:
if not self._hasFixedFontSize:
radius = np.min(
(QDial.width(self) / 2. - self._knobMargin,
QDial.height(self) /
(2. + 2 * fontsize1factor + 2 * fontsize2factor) -
self._knobMargin))
radius = np.max((radius, 1))
# print("Radius = ", radius, ", height = ", QDial.height(self), ", width = ", QDial.width(self))
center_y = center_y - radius * (fontsize1factor +
fontsize2factor)
else:
radius = np.min(
(QDial.width(self) / 2. - self._knobMargin,
(QDial.height(self) - 4 * self._fixedFontSize) / 2. -
self._knobMargin))
radius = np.max((radius, 1))
center_y = center_y - (self._fixedFontSize *
(1 + fontsize2reduction))
else:
radius = self._fixedSize / 2.
radius = np.max((radius, 1))
center_y = center_y - radius * (fontsize1factor +
fontsize2factor)
self.radius = radius
# Draw arc
rectangle = QtCore.QRectF(center_x - radius, center_y - radius,
2 * radius, 2 * radius)
"""The startAngle and spanAngle must be specified in 1/16th of a degree,
i.e. a full circle equals 5760 (16 * 360).
Positive values for the angles mean counter-clockwise
while negative values mean the clockwise direction.
Zero degrees is at the 3 o'clock position."""
linewidth = radius / 30. * 2
# linewidth = 1
pen = QPen(QColor(self._ringColor), linewidth)
pen.setCapStyle(Qt.RoundCap)
# pen.setCapStyle(Qt.FlatCap)
painter.setPen(pen)
# adapt to linewidth to make it more pleasant to the eye
capRadius = linewidth / 4
angleCap = np.arcsin(capRadius / radius)
start_deg = (90 - np.rad2deg(extent / 2)) + np.rad2deg(angleCap)
start_16deg = start_deg * 16
extent_deg = np.rad2deg(extent) - 2 * np.rad2deg(angleCap)
extent_16deg = extent_deg * 16
painter.drawArc(rectangle, start_16deg, extent_16deg)
#draw inner circle
pen = QPen(QColor(pointColor), linewidth)
pen.setCapStyle(Qt.RoundCap)
painter.setPen(pen)
painter.setBrush(QtGui.QColor(bgColor))
radius_inner = 15. / 20. * radius
painter.drawEllipse(QtCore.QPointF(center_x, center_y),
radius_inner, radius_inner)
self.center = QtCore.QPointF(center_x, center_y)
"""
# Get ratio between current value and maximum to calculate angle
if (param != NULL):
if (param->value != this->value())
param->setValue(this->value())
"""
ratio = (QDial.value(self) - QDial.minimum(self)) / (
QDial.maximum(self) - QDial.minimum(self))
# The maximum amount of degrees is 270, offset by 225
angle = ratio * extent - offset
# Draw the indicator
painter.setBrush(QBrush(pointColor))
a_y = center_y + np.sin(angle) * (radius - .1)
a_x = center_x + np.cos(angle) * (radius - .1)
pen = QPen(pointColor, linewidth)
pen.setCapStyle(Qt.RoundCap)
painter.setPen(pen)
painter.drawLine(a_x, a_y, np.round(center_x), center_y)
if not self._hasFixedFontSize:
fontsize1 = radius * fontsize1factor
if self.sizeType == 1 and fontsize1 != Knob.fontsize1:
Knob.fontsize1 = fontsize1
else:
fontsize1 = Knob.fontsize1
fontsize2 = fontsize1 * fontsize2reduction
else:
fontsize1 = self._fixedFontSize
fontsize2 = fontsize1 * fontsize2reduction
self.fontsize1 = fontsize1
textRect_ = QtCore.QRectF(0, center_y + radius, QDial.width(self),
2 * fontsize1)
if self.coloredTitle:
painter.setPen(QColor(int(titleColor, 0)))
f = painter.font()
f.setPointSizeF(fontsize1)
painter.setFont(f)
# painter.drawRect(textRect_)
painter.drawText(textRect_, Qt.AlignHCenter | Qt.AlignTop,
self._text)
# painter.drawText(textRect_, Qt.AlignHCenter | Qt.AlignTop, str(fontsize1))
textRect_ = QtCore.QRectF(0, center_y + radius + fontsize1 * 2,
QDial.width(self), 2 * fontsize2)
if self.hasFocus():
painter.setPen(QtGui.QColor("red"))
f.setPointSizeF(fontsize2)
painter.setFont(f)
# painter.drawRect(textRect_)
painter.drawText(textRect_, Qt.AlignHCenter | Qt.AlignTop,
str(QDial.value(self)))
painter.end()
def fillButtonTriggered(self):
self.scene.setItemColor(QtGui.QColor(self.fillAction.data()))
def setPenColor(self, r, g, b, a):
self.pencolor = QtGui.QColor(r, g, b, a)
def _dark_palette(self) -> QtGui.QPalette:
"""Create a dark themed palette."""
p = QtGui.QPalette()
p.set_color(QtGui.QPalette.Window, QtGui.QColor(35, 35, 35))
p.set_color(QtGui.QPalette.WindowText, QtGui.QColor(247, 247, 247))
p.set_color(QtGui.QPalette.Base, QtGui.QColor(25, 25, 25))
p.set_color(QtGui.QPalette.Text, QtGui.QColor(247, 247, 247))
p.set_color(QtGui.QPalette.Button, QtGui.QColor(60, 60, 60))
p.set_color(QtGui.QPalette.AlternateBase, QtGui.QColor(45, 45, 45))
p.set_color(QtGui.QPalette.ToolTipText, QtCore.Qt.white)
p.set_color(QtGui.QPalette.ButtonText, QtCore.Qt.white)
p.set_color(QtGui.QPalette.PlaceholderText,
QtGui.QColor(110, 110, 100))
p.set_color(QtGui.QPalette.Link, QtGui.QColor(0, 123, 255))
p.set_color(
QtGui.QPalette.Disabled,
QtGui.QPalette.Light,
QtGui.QColor(0, 0, 0),
)
p.set_color(
QtGui.QPalette.Disabled,
QtGui.QPalette.Text,
QtGui.QColor(110, 110, 100),
)
p.set_color(
QtGui.QPalette.Disabled,
QtGui.QPalette.ButtonText,
QtGui.QColor(110, 110, 100),
)
p.set_color(
QtGui.QPalette.Disabled,
QtGui.QPalette.Button,
QtGui.QColor(50, 50, 50),
)
return p
def setColor(self):
action = self.sender()
if action is not None and isinstance(action, QtGui.QAction):
color = QtGui.QColor(action.data())
if color.isValid():
self.setTextColor(color)
def paintEvent(self, event=None):
LogicalSize = 100.0
def logicalFromPhysical(length, side):
return (length / side) * LogicalSize
fm = QtGui.QFontMetricsF(self.font())
ymargin = (LogicalSize / 30.0) + logicalFromPhysical(
self.leftSpinBox.height(), self.height())
ymax = int(LogicalSize -
logicalFromPhysical(fm.height() * 2, self.height()))
width = int(LogicalSize / 4.0)
cx, cy = int(LogicalSize / 2.0), int(LogicalSize / 3.0)
ax, ay = cx - int(2 * width), ymargin
bx, by = cx - width, ay
dx, dy = cx + width, ay
ex, ey = cx + int(2 * width), ymargin
fx, fy = cx + int(width / 2), cx + int(LogicalSize / 24.0)
gx, gy = fx, ymax
hx, hy = cx - int(width / 2), ymax
ix, iy = hx, fy
painter = QtGui.QPainter(self)
painter.setRenderHint(QtGui.QPainter.Antialiasing)
side = min(self.width(), self.height())
painter.setViewport((self.width() - side) / 2,
(self.height() - side) / 2, side, side)
painter.setWindow(0, 0, LogicalSize, LogicalSize)
painter.setPen(QtCore.Qt.NoPen)
gradient = QtGui.QLinearGradient(QtCore.QPointF(0, 0),
QtCore.QPointF(0, 100))
gradient.setColorAt(0, QtCore.Qt.white)
a = self.leftSpinBox.value()
gradient.setColorAt(1, (QtCore.Qt.red if a != 0 else QtCore.Qt.white))
painter.setBrush(QtGui.QBrush(gradient))
painter.drawPolygon(
QtGui.QPolygon([
QtCore.QPoint(ax, ay),
QtCore.QPoint(bx, by),
QtCore.QPoint(cx, cy),
QtCore.QPoint(ix, iy)
]))
gradient = QtGui.QLinearGradient(QtCore.QPointF(0, 0),
QtCore.QPointF(0, 100))
gradient.setColorAt(0, QtCore.Qt.white)
b = self.rightSpinBox.value()
gradient.setColorAt(1, (QtCore.Qt.blue if b != 0 else QtCore.Qt.white))
painter.setBrush(QtGui.QBrush(gradient))
painter.drawPolygon(
QtGui.QPolygon([
QtCore.QPoint(cx, cy),
QtCore.QPoint(dx, dy),
QtCore.QPoint(ex, ey),
QtCore.QPoint(fx, fy)
]))
if (a + b) == 0:
color = QtGui.QColor(QtCore.Qt.white)
else:
ashare = int((a / (a + b)) * 255.0)
bshare = int(255.0 - ashare)
color = QtGui.QColor(ashare, 0, bshare)
gradient = QtGui.QLinearGradient(QtCore.QPointF(0, 0),
QtCore.QPointF(0, 100))
gradient.setColorAt(0, QtCore.Qt.white)
gradient.setColorAt(1, color)
painter.setBrush(QtGui.QBrush(gradient))
painter.drawPolygon(
QtGui.QPolygon([
QtCore.QPoint(cx, cy),
QtCore.QPoint(fx, fy),
QtCore.QPoint(gx, gy),
QtCore.QPoint(hx, hy),
QtCore.QPoint(ix, iy)
]))
painter.setPen(QtCore.Qt.black)
painter.drawPolyline(
QtGui.QPolygon([
QtCore.QPoint(ax, ay),
QtCore.QPoint(ix, iy),
QtCore.QPoint(hx, hy)
]))
painter.drawPolyline(
QtGui.QPolygon([
QtCore.QPoint(gx, gy),
QtCore.QPoint(fx, fy),
QtCore.QPoint(ex, ey)
]))
painter.drawPolyline(
QtGui.QPolygon([
QtCore.QPoint(bx, by),
QtCore.QPoint(cx, cy),
QtCore.QPoint(dx, dy)
]))
def _draw_background(self) -> None:
self._item.setBackground(
QtGui.QBrush(QtGui.QColor(Cell.default_background_color))
)
def paintEvent(self, ev):
p = QtGui.QPainter(self)
p.fillRect(self.rect(), QtGui.QColor(0xCC, 0xCC, 0xCC))
p.drawImage(self.m_background.rect(), self.m_background,
self.m_background.rect())
self.drawLogo(p)
def _setPpColor(self, color: str):
# print("setfixedSize called")
self._ppColor = QtGui.QColor(color)
def __init__(self, *args, **kwargs):
super(NestedItem, self).__init__(*args, **kwargs)
self.setBrush(QtGui.QBrush(QtGui.QColor(255, 113, 91, 255)))
self.source_name_label.setText(self.item.name)
def setupUi(self, Dialog):
Dialog.setObjectName("Dialog")
Dialog.resize(216, 215)
Dialog.setStyleSheet("background-color: rgb(53, 53, 53);\n"
"color: rgb(255, 255, 255);")
self.Button_7 = QtWidgets.QPushButton(Dialog)
self.Button_7.setGeometry(QtCore.QRect(10, 50, 51, 41))
self.Button_7.setObjectName("Button_7")
self.Button_8 = QtWidgets.QPushButton(Dialog)
self.Button_8.setGeometry(QtCore.QRect(60, 50, 51, 41))
self.Button_8.setStyleSheet("color: rgb(255, 255, 255);")
self.Button_8.setObjectName("Button_8")
self.Button_9 = QtWidgets.QPushButton(Dialog)
self.Button_9.setGeometry(QtCore.QRect(110, 50, 51, 41))
self.Button_9.setObjectName("Button_9")
self.Button_4 = QtWidgets.QPushButton(Dialog)
self.Button_4.setGeometry(QtCore.QRect(10, 90, 51, 41))
self.Button_4.setObjectName("Button_4")
self.Button_5 = QtWidgets.QPushButton(Dialog)
self.Button_5.setGeometry(QtCore.QRect(60, 90, 51, 41))
self.Button_5.setObjectName("Button_5")
self.Button_6 = QtWidgets.QPushButton(Dialog)
self.Button_6.setGeometry(QtCore.QRect(110, 90, 51, 41))
self.Button_6.setObjectName("Button_6")
self.Button_1 = QtWidgets.QPushButton(Dialog)
self.Button_1.setGeometry(QtCore.QRect(10, 130, 51, 41))
self.Button_1.setObjectName("Button_1")
self.Button_2 = QtWidgets.QPushButton(Dialog)
self.Button_2.setGeometry(QtCore.QRect(60, 130, 51, 41))
self.Button_2.setObjectName("Button_2")
self.Button_3 = QtWidgets.QPushButton(Dialog)
self.Button_3.setGeometry(QtCore.QRect(110, 130, 51, 41))
self.Button_3.setObjectName("Button_3")
self.Button_0 = QtWidgets.QPushButton(Dialog)
self.Button_0.setGeometry(QtCore.QRect(10, 170, 51, 41))
self.Button_0.setObjectName("Button_0")
self.Button_equals = QtWidgets.QPushButton(Dialog)
self.Button_equals.setGeometry(QtCore.QRect(60, 170, 101, 41))
palette = QtGui.QPalette()
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.WindowText,
brush)
brush = QtGui.QBrush(QtGui.QColor(255, 170, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Button, brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Text, brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.ButtonText,
brush)
brush = QtGui.QBrush(QtGui.QColor(255, 170, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Base, brush)
brush = QtGui.QBrush(QtGui.QColor(255, 170, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Window, brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.WindowText,
brush)
brush = QtGui.QBrush(QtGui.QColor(255, 170, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Button, brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Text, brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.ButtonText,
brush)
brush = QtGui.QBrush(QtGui.QColor(255, 170, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Base, brush)
brush = QtGui.QBrush(QtGui.QColor(255, 170, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Window, brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.WindowText,
brush)
brush = QtGui.QBrush(QtGui.QColor(255, 170, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Button, brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Text, brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.ButtonText,
brush)
brush = QtGui.QBrush(QtGui.QColor(255, 170, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Base, brush)
brush = QtGui.QBrush(QtGui.QColor(255, 170, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Window, brush)
self.Button_equals.setPalette(palette)
self.Button_equals.setStyleSheet("background-color: rgb(255, 170, 0);")
self.Button_equals.setObjectName("Button_equals")
self.Button_add = QtWidgets.QPushButton(Dialog)
self.Button_add.setGeometry(QtCore.QRect(160, 170, 51, 41))
self.Button_add.setStyleSheet("background-color: rgb(255, 170, 0);")
self.Button_add.setObjectName("Button_add")
self.Button_sub = QtWidgets.QPushButton(Dialog)
self.Button_sub.setGeometry(QtCore.QRect(160, 130, 51, 41))
self.Button_sub.setStyleSheet("background-color: rgb(255, 170, 0);")
self.Button_sub.setObjectName("Button_sub")
self.Button_divide = QtWidgets.QPushButton(Dialog)
self.Button_divide.setGeometry(QtCore.QRect(160, 90, 51, 41))
self.Button_divide.setStyleSheet("background-color: rgb(255, 170, 0);")
self.Button_divide.setObjectName("Button_divide")
self.Button_multi = QtWidgets.QPushButton(Dialog)
self.Button_multi.setGeometry(QtCore.QRect(160, 50, 51, 41))
self.Button_multi.setStyleSheet("background-color: rgb(255, 170, 0);")
self.Button_multi.setObjectName("Button_multi")
self.Button_clear = QtWidgets.QPushButton(Dialog)
self.Button_clear.setGeometry(QtCore.QRect(160, 10, 51, 41))
self.Button_clear.setStyleSheet("background-color: rgb(255, 170, 0);")
self.Button_clear.setObjectName("Button_clear")
self.display = QtWidgets.QLabel(Dialog)
self.display.setGeometry(QtCore.QRect(10, 10, 141, 41))
font = QtGui.QFont()
font.setPointSize(18)
self.display.setFont(font)
self.display.setLayoutDirection(QtCore.Qt.RightToLeft)
self.display.setObjectName("display")
self.retranslateUi(Dialog)
QtCore.QMetaObject.connectSlotsByName(Dialog)
# all clicked commands for each button connecting to the commands for calculator functions
self.Button_clear.clicked.connect(self.clear)
self.Button_0.clicked.connect(self.press_0)
self.Button_1.clicked.connect(self.press_1)
self.Button_2.clicked.connect(self.press_2)
self.Button_3.clicked.connect(self.press_3)
self.Button_4.clicked.connect(self.press_4)
self.Button_5.clicked.connect(self.press_5)
self.Button_6.clicked.connect(self.press_6)
self.Button_7.clicked.connect(self.press_7)
self.Button_8.clicked.connect(self.press_8)
self.Button_9.clicked.connect(self.press_9)
self.Button_add.clicked.connect(self.plus)
self.Button_sub.clicked.connect(self.minus)
self.Button_multi.clicked.connect(self.times)
self.Button_divide.clicked.connect(self.divide)
self.Button_equals.clicked.connect(self.sum)
def __init__(self, *args, **kwargs):
super(GapItem, self).__init__(*args, **kwargs)
self.setBrush(QtGui.QBrush(QtGui.QColor(100, 100, 100, 255)))
self.source_name_label.setText('GAP')
def __init__(self, parent=None):
QtOpenGLWidgets.QOpenGLWidget.__init__(self, parent)
QtGui.QOpenGLFunctions.__init__(self)
self.m_shaderProgram = None
self.m_shaderHeightMapProgram = None
self.m_shaderBasicProgram = None
self.m_xRot = 90.0
self.m_yRot = 0.0
self.m_xLastRot = 0.0
self.m_yLastRot = 0.0
self.m_xPan = 0.0
self.m_yPan = 0.0
self.m_xLastPan = 0.0
self.m_yLastPan = 0.0
self.m_xLookAt = 0.0
self.m_yLookAt = 0.0
self.m_zLookAt = 0.0
self.m_lastPos = QtCore.QPoint(0, 0)
self.m_zoom = 1
self.m_distance = 100.0
self.m_xMin = 0.0
self.m_xMax = 0.0
self.m_yMin = 0.0
self.m_yMax = 0.0
self.m_zMin = 0.0
self.m_zMax = 0.0
self.m_xSize = 0.0
self.m_ySize = 0.0
self.m_zSize = 0.0
self.m_lineWidth = 0.0
self.m_pointSize = 0.0
self.m_antialiasing = True
self.m_msaa = True
self.m_zBuffer = True
self.m_frames = 0
self.m_fps = 0
self.m_animationFrame = 0
self.m_timerPaint = QtCore.QBasicTimer()
self.m_xRotTarget = 90.0
self.m_yRotTarget = 0.0
self.m_xRotStored = 0.0
self.m_yRotStored = 0.0
self.m_animateView = False
self.m_parserStatus = ""
self.m_speedState = ""
self.m_pinState = ""
self.m_bufferState = ""
self.m_updatesEnabled = False
self.m_projectionMatrix = QtGui.QMatrix4x4()
self.m_viewMatrix = QtGui.QMatrix4x4()
self.m_colorBackground = QtGui.QColor(255,255,255)
self.m_colorText = QtGui.QColor()
self.m_shaderDrawables : List[ShaderDrawable] = []
self.updateProjection()
self.updateView()
self.m_spendTime = QtCore.QTime()
self.m_spendTime.setHMS(0, 0, 0)
self.m_estimatedTime = QtCore.QTime()
self.m_estimatedTime.setHMS(0, 0, 0)
self.m_vsync = False
self.m_targetFps = 60
self.cmdFit = QtWidgets.QToolButton(self)
self.cmdIsometric = QtWidgets.QToolButton(self)
self.cmdTop = QtWidgets.QToolButton(self)
self.cmdFront = QtWidgets.QToolButton(self)
self.cmdLeft = QtWidgets.QToolButton(self)
self.cmdFit.setMinimumSize(QtCore.QSize(24,24))
self.cmdIsometric.setMinimumSize(QtCore.QSize(24,24))
self.cmdTop.setMinimumSize(QtCore.QSize(24,24))
self.cmdFront.setMinimumSize(QtCore.QSize(24,24))
self.cmdLeft.setMinimumSize(QtCore.QSize(24,24))
self.cmdFit.setMaximumSize(QtCore.QSize(24,24))
self.cmdIsometric.setMaximumSize(QtCore.QSize(24,24))
self.cmdTop.setMaximumSize(QtCore.QSize(24,24))
self.cmdFront.setMaximumSize(QtCore.QSize(24,24))
self.cmdLeft.setMaximumSize(QtCore.QSize(24,24))
self.cmdFit.setToolTip("Fit")
self.cmdIsometric.setToolTip("Isometric view")
self.cmdTop.setToolTip("Top view")
self.cmdFront.setToolTip("Front view")
self.cmdLeft.setToolTip("Left view")
self.cmdFit.setIcon(QtGui.QIcon(":/images/candle/fit_1.png"))
self.cmdIsometric.setIcon(QtGui.QIcon(":/images/candle/cube.png"))
self.cmdTop.setIcon(QtGui.QIcon(":/images/candle/cubeTop.png"))
self.cmdFront.setIcon(QtGui.QIcon(":/images/candle/cubeFront.png"))
self.cmdLeft.setIcon(QtGui.QIcon(":/images/candle/cubeLeft.png"))
self.cmdFit.clicked.connect(self.on_cmdFit_clicked)
self.cmdIsometric.clicked.connect(self.on_cmdIsometric_clicked)
self.cmdTop.clicked.connect(self.on_cmdTop_clicked)
self.cmdFront.clicked.connect(self.on_cmdFront_clicked)
self.cmdLeft.clicked.connect(self.on_cmdLeft_clicked)
self.rotationChanged.connect(self.onVisualizatorRotationChanged)
self.resized.connect(self.placeVisualizerButtons)
QtCore.QTimer.singleShot(1000, self.onFramesTimer)
def setBrushColor(self, r, g, b, a):
self.brushcolor = QtGui.QColor(r, g, b, a)
if __name__ == '__main__':
import sys
import math
app = QtWidgets.QApplication(sys.argv)
scene = QtWidgets.QGraphicsScene(-200, -200, 400, 400)
for i in range(10):
item = ColorItem()
angle = i * 6.28 / 10.0
item.setPos(math.sin(angle) * 150, math.cos(angle) * 150)
scene.addItem(item)
robot = Robot()
robot.setTransform(QtGui.QTransform().scale(1.2, 1.2))
robot.setPos(0, -20)
scene.addItem(robot)
view = QtWidgets.QGraphicsView(scene)
view.setRenderHint(QtGui.QPainter.Antialiasing)
view.setViewportUpdateMode(
QtWidgets.QGraphicsView.BoundingRectViewportUpdate)
view.setBackgroundBrush(QtGui.QColor(230, 200, 167))
view.setWindowTitle("Drag and Drop Robot")
view.show()
sys.exit(app.exec_())
def paintEvent(self, pe) -> None:
mainradius, fontsizefactor, center_x, center_y_pp, width = self.computeCenter(
)
painter = QPainter(self)
# So that we can use the background color
painter.setBackgroundMode(Qt.OpaqueMode)
# Smooth out the circle
painter.setRenderHint(QPainter.Antialiasing)
# Use background color
textBgColor = QColor(painter.background().color())
# print("bgcolor = ", bgColor)
bgColor = QColor("transparent")
pointColor = QColor(painter.pen().color())
self.pointColor = pointColor
self.bgColor = textBgColor
alpha = 150
if self.parent().displayPp == 'all' or self.parent(
).displayPp == self.io:
pointColor.setAlpha(255)
else:
pointColor.setAlpha(alpha)
# draw text
if not self._hasFixedFontSize:
fontsize = mainradius * fontsizefactor
else:
fontsize = self._fixedFontSize
self.fontsize = fontsize
textRect_ = QtCore.QRectF(0, center_y_pp - mainradius - 2 * fontsize,
width, 2 * fontsize)
f = painter.font()
f.setPointSizeF(fontsize)
# self._io = 'in'
if self.io == 'out':
fm = QFontMetrics(f).boundingRect(self._text)
# print("fm = ", fm)
painter.setBrush(pointColor)
painter.setPen(QPen(pointColor))
painter.drawRect(
QtCore.QRectF(center_x - fm.width() / 2,
center_y_pp - mainradius - 2 * fontsize,
fm.width(), fm.height()))
painter.setPen(QPen(textBgColor))
painter.setFont(f)
painter.setBackgroundMode(Qt.TransparentMode)
painter.drawText(textRect_, Qt.AlignHCenter | Qt.AlignTop, self._text)
# draw hexagon
painter.setBrush(bgColor)
painter.setPen(pointColor)
painter.drawPolygon(
self.createPoly(6, mainradius, center_x, center_y_pp))
# draw outer circle
radius_outer = mainradius * .8
if self.title not in implementedPatchPoints:
painter.setBrush(QtGui.QBrush(QtGui.QColor(int("0x999999", 0))))
painter.drawEllipse(QtCore.QPointF(center_x, center_y_pp),
radius_outer, radius_outer)
# draw inner circle
radius_inner = mainradius * .5
# painter.setBrush(QBrush(pointColor))
painter.setBrush(QColor(self._ppColor))
painter.drawEllipse(QtCore.QPointF(center_x, center_y_pp),
radius_inner, radius_inner)
def itemChange(self, change, value):
if change == QtWidgets.QGraphicsItem.ItemSelectedHasChanged:
self.setPen(
QtGui.QColor(0, 255, 0, 255) if self.isSelected() else QtGui.
QColor(0, 0, 0, 255))
return super(Ruler, self).itemChange(change, value)
def init_gui(self):
"""Separate function for GUI initialization"""
self._init_layout([self.label], margins=(3, 3, 3, 3))
self._init_palette({qtg.QPalette.Window: qtg.QColor("#5d4a66")})
def __init__(self, parent=None):
QtWidgets.QWidget.__init__(self, parent)
self.currentAngle = 45
self.setPalette(QtGui.QPalette(QtGui.QColor(250, 250, 200)))
self.setAutoFillBackground(True)
def setResizeBoxColor(self, color):
if isinstance(color, str):
color = QtGui.QColor(color)
self.resizeBoxColor = color
self.setupResizeBox()
def __init__(self, config):
super().__init__()
self._scene_opts_widget = None
self._scene_extra_args = {}
self._scn_view = QtWidgets.QTreeView()
self._scn_view.setHeaderHidden(True)
self._scn_view.setSelectionBehavior(QtWidgets.QAbstractItemView.SelectRows)
self._scn_view.setEditTriggers(QtWidgets.QAbstractItemView.NoEditTriggers)
self._scn_mdl = QtGui.QStandardItemModel()
self._scn_view.setModel(self._scn_mdl)
self._current_scene_data = None
all_ar = config.CHOICES["aspect_ratio"]
default_ar = config.get("aspect_ratio")
self._ar_cbbox = QtWidgets.QComboBox()
for ar in all_ar:
self._ar_cbbox.addItem("%d:%d" % ar)
self._ar_cbbox.setCurrentIndex(all_ar.index(default_ar))
ar_lbl = QtWidgets.QLabel("Aspect ratio:")
ar_hbox = QtWidgets.QHBoxLayout()
ar_hbox.addWidget(ar_lbl)
ar_hbox.addWidget(self._ar_cbbox)
self._far_lbl = QtWidgets.QLabel("Forced aspect ratio:")
self._far_lbl.setStyleSheet("color: red;")
self._far_lbl.setVisible(False)
self._far_lbl2 = QtWidgets.QLabel("1:1")
self._far_lbl2.setStyleSheet("color: red;")
self._far_lbl2.setVisible(False)
far_hbox = QtWidgets.QHBoxLayout()
far_hbox.addWidget(self._far_lbl)
far_hbox.addWidget(self._far_lbl2)
all_samples = config.CHOICES["samples"]
default_samples = config.get("samples")
self._samples_cbbox = QtWidgets.QComboBox()
for samples in all_samples:
self._samples_cbbox.addItem("%dx" % samples if samples else "Disabled")
self._samples_cbbox.setCurrentIndex(all_samples.index(default_samples))
samples_lbl = QtWidgets.QLabel("MSAA:")
samples_hbox = QtWidgets.QHBoxLayout()
samples_hbox.addWidget(samples_lbl)
samples_hbox.addWidget(self._samples_cbbox)
all_fr = config.CHOICES["framerate"]
default_fr = config.get("framerate")
self._fr_cbbox = QtWidgets.QComboBox()
for fr in all_fr:
self._fr_cbbox.addItem("%.5g FPS" % (fr[0] / float(fr[1])))
self._fr_cbbox.setCurrentIndex(all_fr.index(default_fr))
fr_lbl = QtWidgets.QLabel("Frame rate:")
fr_hbox = QtWidgets.QHBoxLayout()
fr_hbox.addWidget(fr_lbl)
fr_hbox.addWidget(self._fr_cbbox)
all_loglevels = config.CHOICES["log_level"]
default_loglevel = config.get("log_level")
self._loglevel_cbbox = QtWidgets.QComboBox()
for level in all_loglevels:
self._loglevel_cbbox.addItem(level.title())
log_level_idx = all_loglevels.index(default_loglevel)
self._loglevel_cbbox.setCurrentIndex(log_level_idx)
self._set_loglevel(log_level_idx)
loglevel_lbl = QtWidgets.QLabel("Min log level:")
loglevel_hbox = QtWidgets.QHBoxLayout()
loglevel_hbox.addWidget(loglevel_lbl)
loglevel_hbox.addWidget(self._loglevel_cbbox)
backend_names = {
"opengl": "OpenGL",
"opengles": "OpenGL ES",
"vulkan": "Vulkan",
}
all_backends = config.CHOICES["backend"]
default_backend = config.get("backend")
self._backend_cbbox = QtWidgets.QComboBox()
for backend in all_backends:
self._backend_cbbox.addItem(backend_names[backend])
backend_idx = all_backends.index(default_backend)
self._backend_cbbox.setCurrentIndex(backend_idx)
backend_lbl = QtWidgets.QLabel("Backend:")
backend_hbox = QtWidgets.QHBoxLayout()
backend_hbox.addWidget(backend_lbl)
backend_hbox.addWidget(self._backend_cbbox)
default_clearcolor = config.get("clear_color")
self._clearcolor_btn = QtWidgets.QPushButton()
color = QtGui.QColor()
color.setRgbF(*default_clearcolor)
self._set_widget_clear_color(color)
self._clearcolor_btn.pressed.connect(self._set_clear_color)
clearcolor_lbl = QtWidgets.QLabel("Clear color:")
clearcolor_hbox = QtWidgets.QHBoxLayout()
clearcolor_hbox.addWidget(clearcolor_lbl)
clearcolor_hbox.addWidget(self._clearcolor_btn)
self.reload_btn = QtWidgets.QPushButton("Force scripts reload")
self._scene_toolbar_layout = QtWidgets.QVBoxLayout(self)
self._scene_toolbar_layout.addLayout(ar_hbox)
self._scene_toolbar_layout.addLayout(far_hbox)
self._scene_toolbar_layout.addLayout(samples_hbox)
self._scene_toolbar_layout.addLayout(fr_hbox)
self._scene_toolbar_layout.addLayout(loglevel_hbox)
self._scene_toolbar_layout.addLayout(backend_hbox)
self._scene_toolbar_layout.addLayout(clearcolor_hbox)
self._scene_toolbar_layout.addWidget(self.reload_btn)
self._scene_toolbar_layout.addWidget(self._scn_view)
self._scn_view.clicked.connect(self._scn_view_selected)
self._scn_view.activated.connect(self._scn_view_selected)
self._ar_cbbox.currentIndexChanged.connect(self._set_aspect_ratio)
self._samples_cbbox.currentIndexChanged.connect(self._set_samples)
self._fr_cbbox.currentIndexChanged.connect(self._set_frame_rate)
self._loglevel_cbbox.currentIndexChanged.connect(self._set_loglevel)
self._backend_cbbox.currentIndexChanged.connect(self._set_backend)
def __init__(self) -> None:
super().__init__()
self._presenter = MainPresenter(self)
self.showMaximized()
self.setWindowTitle("Eisenhower")
self.setAcceptDrops(True)
palette = self.palette()
palette.setColor(QtGui.QPalette.Window, QtGui.QColor(50, 54, 76))
self.setPalette(palette)
layout = QtWidgets.QHBoxLayout(self)
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(0)
self._undo_button = QtWidgets.QPushButton("Undo")
self._redo_button = QtWidgets.QPushButton("Redo")
self._add_task_button = QtWidgets.QPushButton("Add Task")
self._show_archive_button = QtWidgets.QPushButton("Show Archive")
self._priority_button = QtWidgets.QPushButton("Priority Mode")
self._priority_button.setCheckable(True)
_style_button(self._undo_button)
_style_button(self._redo_button)
_style_button(self._add_task_button)
_style_button(self._show_archive_button)
_style_button(self._priority_button)
button_layout = QtWidgets.QVBoxLayout()
layout.addLayout(button_layout)
button_layout.addWidget(self._add_task_button)
button_layout.addWidget(self._undo_button)
button_layout.addWidget(self._redo_button)
button_layout.addWidget(self._show_archive_button)
button_layout.addWidget(self._priority_button)
button_layout.addStretch()
self._do_list = DividedTasksView("Do", QtGui.QColor(240, 98, 146),
self)
self._decide_list = DividedTasksView("Decide",
QtGui.QColor(255, 149, 157), self)
self._delegate_list = DividedTasksView("Delegate",
QtGui.QColor(255, 215, 140),
self)
self._drop_list = DividedTasksView("Drop", QtGui.QColor(128, 222, 234),
self)
task_layout = QtWidgets.QHBoxLayout()
task_layout.setContentsMargins(0, 0, 0, 0)
task_layout.setSpacing(5)
layout.addLayout(task_layout)
for task_list in (self._do_list, self._decide_list,
self._delegate_list, self._drop_list):
task_layout.addWidget(task_list)
task_list.complete_task_requested.connect(
self._presenter.complete_task)
task_list.delete_task_requested.connect(
self._presenter.delete_task)
task_list.rename_task_requested.connect(
self._presenter.rename_task)
task_list.schedule_task_requested.connect(
self._presenter.set_task_due)
task_list.snooze_task_requested.connect(
self._presenter.set_task_snooze)
task_list.add_task_requested.connect(self._add_task)
task_list.remove_due_requested.connect(
lambda task: self._presenter.set_task_due(task, None))
task_list.remove_snooze_requested.connect(
lambda task: self._presenter.set_task_snooze(task, None))
task_list.set_important_requested.connect(
lambda task: self._presenter.set_importance(
task, Importance.Important))
task_list.set_unimportant_requested.connect(
lambda task: self._presenter.set_importance(
task, Importance.Unimportant))
self._undo_button.clicked.connect(self._presenter.undo)
self._redo_button.clicked.connect(self._presenter.redo)
self._add_task_button.clicked.connect(self._add_task)
self._show_archive_button.clicked.connect(self._show_archive)
self._priority_button.toggled.connect(self._toggle_priority)
self._archive_view = TasksView((Column.Name, Column.Archived),
QtGui.QColor(255, 255, 255), self)
self._archive_view.setWindowFlag(QtGui.Qt.Window)
self._archive_view.setWindowTitle("Task Archive")
self._archive_view.sortByColumn(1, QtCore.Qt.SortOrder.DescendingOrder)
self._archive_view.hide()
self._archive_view.delete_task_requested.connect(
self._presenter.delete_task)
self._archive_view.unarchive_task_requested.connect(
lambda task: self._presenter.complete_task(task, False))
self._presenter.request_update()
def _light_palette(self) -> QtGui.QPalette:
"""Create a light themed palette."""
p = self._app.style().standard_palette()
p.set_color(QtGui.QPalette.Link, QtGui.QColor(0, 123, 255))
return p
def setup_central_widget(self):
patient_dict_container = PatientDictContainer()
self.central_widget = QtWidgets.QWidget()
self.central_widget_layout = QVBoxLayout()
self.patient_bar = PatientBar()
splitter = QtWidgets.QSplitter(QtCore.Qt.Horizontal)
# Left panel contains stuctures tab, isodoses tab,
# and structure information
self.left_panel = QtWidgets.QTabWidget()
self.left_panel.setMinimumWidth(300)
self.left_panel.setMaximumWidth(500)
# Add structures tab to left panel
if not hasattr(self, 'structures_tab'):
self.structures_tab = StructureTab()
self.structures_tab.request_update_structures.connect(
self.update_views)
else:
self.structures_tab.update_ui()
self.left_panel.addTab(self.structures_tab, "Structures")
if patient_dict_container.has_modality("rtdose"):
self.isodoses_tab = IsodoseTab()
self.isodoses_tab.request_update_isodoses.connect(
self.update_views)
self.isodoses_tab.request_update_ui.connect(
self.structures_tab.fixed_container_structure_modified)
self.left_panel.addTab(self.isodoses_tab, "Isodoses")
elif hasattr(self, 'isodoses_tab'):
del self.isodoses_tab
# Right panel contains the different tabs of DICOM view, DVH,
# clinical data, DICOM tree
self.right_panel = QtWidgets.QTabWidget()
# Create a Dicom View containing single-slice and 3-slice views
self.dicom_view = DicomStackedWidget(self.format_data)
roi_color_dict = self.structures_tab.color_dict if hasattr(
self, 'structures_tab') else None
iso_color_dict = self.isodoses_tab.color_dict if hasattr(
self, 'isodoses_tab') else None
self.dicom_single_view = DicomAxialView(
roi_color=roi_color_dict, iso_color=iso_color_dict)
self.dicom_axial_view = DicomAxialView(
is_four_view=True, roi_color=roi_color_dict, iso_color=iso_color_dict,
metadata_formatted=True, cut_line_color=QtGui.QColor(255, 0, 0))
self.dicom_sagittal_view = DicomSagittalView(
roi_color=roi_color_dict, iso_color=iso_color_dict,
cut_line_color=QtGui.QColor(0, 255, 0))
self.dicom_coronal_view = DicomCoronalView(
roi_color=roi_color_dict, iso_color=iso_color_dict,
cut_line_color=QtGui.QColor(0, 0, 255))
self.three_dimension_view = DicomView3D()
# Rescale the size of the scenes inside the 3-slice views
self.dicom_axial_view.zoom = INITIAL_FOUR_VIEW_ZOOM
self.dicom_sagittal_view.zoom = INITIAL_FOUR_VIEW_ZOOM
self.dicom_coronal_view.zoom = INITIAL_FOUR_VIEW_ZOOM
self.dicom_axial_view.update_view(zoom_change=True)
self.dicom_sagittal_view.update_view(zoom_change=True)
self.dicom_coronal_view.update_view(zoom_change=True)
self.dicom_four_views = QWidget()
self.dicom_four_views_layout = QGridLayout()
for i in range(2):
self.dicom_four_views_layout.setColumnStretch(i, 1)
self.dicom_four_views_layout.setRowStretch(i, 1)
self.dicom_four_views_layout.addWidget(self.dicom_axial_view, 0, 0)
self.dicom_four_views_layout.addWidget(self.dicom_sagittal_view, 0, 1)
self.dicom_four_views_layout.addWidget(self.dicom_coronal_view, 1, 0)
self.dicom_four_views_layout.addWidget(self.three_dimension_view, 1, 1)
self.dicom_four_views.setLayout(self.dicom_four_views_layout)
self.dicom_view.addWidget(self.dicom_four_views)
self.dicom_view.addWidget(self.dicom_single_view)
self.dicom_view.setCurrentWidget(self.dicom_single_view)
# Add DICOM View to right panel as a tab
self.right_panel.addTab(self.dicom_view, "DICOM View")
# Add PETVT View to right panel as a tab
self.pet_ct_tab = PetCtView()
self.right_panel.addTab(self.pet_ct_tab, "PET/CT View")
# Add DVH tab to right panel as a tab
if patient_dict_container.has_modality("rtdose"):
self.dvh_tab = DVHTab()
self.right_panel.addTab(self.dvh_tab, "DVH")
elif hasattr(self, 'dvh_tab'):
del self.dvh_tab
# Add DICOM Tree View tab
self.dicom_tree = DicomTreeView()
self.right_panel.addTab(self.dicom_tree, "DICOM Tree")
# Connect SUV2ROI signal to handler function
self.dicom_single_view.suv2roi_signal.connect(self.perform_suv2roi)
# Add clinical data tab
self.call_class.display_clinical_data(self.right_panel)
splitter.addWidget(self.left_panel)
splitter.addWidget(self.right_panel)
# Create footer
self.footer = QtWidgets.QWidget()
self.create_footer()
# Set layout
self.central_widget_layout.addWidget(self.patient_bar)
self.central_widget_layout.addWidget(splitter)
self.central_widget_layout.addWidget(self.footer)
self.central_widget.setLayout(self.central_widget_layout)
self.main_window_instance.setCentralWidget(self.central_widget)
def textButtonTriggered(self):
self.scene.setTextColor(QtGui.QColor(self.textAction.data()))
def create_image_fusion_tab(self):
"""
This function is used to create the tab for image fusion.
Function checks if the moving dict container contains rtss to
load rtss. Views are created and stacked into three window view.
"""
# Set a flag for Zooming
self.action_handler.has_image_registration_four = True
# Instance of Moving Model
moving_dict_container = MovingDictContainer()
if moving_dict_container.has_modality("rtss"):
if len(self.structures_tab.rois.items()) == 0:
self.structures_tab.update_ui(moving=True)
# else:
# TODO: Display both ROIs in the same tab
self.image_fusion_single_view \
= ImageFusionAxialView()
self.image_fusion_view = QStackedWidget()
self.image_fusion_view_axial = ImageFusionAxialView(
metadata_formatted=False,
cut_line_color=QtGui.QColor(255, 0, 0))
self.image_fusion_view_sagittal = ImageFusionSagittalView(
cut_line_color=QtGui.QColor(0, 255, 0))
self.image_fusion_view_coronal = ImageFusionCoronalView(
cut_line_color=QtGui.QColor(0, 0, 255))
self.image_fusion_roi_transfer_option_view = ROITransferOptionView(
self.structures_tab.fixed_container_structure_modified,
self.structures_tab.moving_container_structure_modified)
# Rescale the size of the scenes inside the 3-slice views
self.image_fusion_view_axial.zoom = INITIAL_FOUR_VIEW_ZOOM
self.image_fusion_view_sagittal.zoom = INITIAL_FOUR_VIEW_ZOOM
self.image_fusion_view_coronal.zoom = INITIAL_FOUR_VIEW_ZOOM
self.image_fusion_view_axial.update_view(zoom_change=True)
self.image_fusion_view_sagittal.update_view(zoom_change=True)
self.image_fusion_view_coronal.update_view(zoom_change=True)
self.image_fusion_four_views = QWidget()
self.image_fusion_four_views_layout = QGridLayout()
for i in range(2):
self.image_fusion_four_views_layout.setColumnStretch(i, 1)
self.image_fusion_four_views_layout.setRowStretch(i, 1)
self.image_fusion_four_views_layout.addWidget(
self.image_fusion_view_axial, 0, 0)
self.image_fusion_four_views_layout.addWidget(
self.image_fusion_view_sagittal, 0, 1)
self.image_fusion_four_views_layout.addWidget(
self.image_fusion_view_coronal, 1, 0)
self.image_fusion_four_views_layout.addWidget(
self.image_fusion_roi_transfer_option_view, 1, 1
)
self.image_fusion_four_views.setLayout(
self.image_fusion_four_views_layout)
self.image_fusion_view.addWidget(self.image_fusion_four_views)
self.image_fusion_view.addWidget(self.image_fusion_single_view)
self.image_fusion_view.setCurrentWidget(self.image_fusion_four_views)
# Add Image Fusion Tab
self.right_panel.addTab(self.image_fusion_view, "Image Fusion")
self.right_panel.setCurrentWidget(self.image_fusion_view)
# Update the Add On Option GUI
self.add_on_options_controller.update_ui()
def lineButtonTriggered(self):
self.scene.setLineColor(QtGui.QColor(self.lineAction.data()))
class View(QtWidgets.QGraphicsView):
_background_color = QtGui.QColor(38, 38, 38)
_grid_pen_s = QtGui.QPen(QtGui.QColor(52, 52, 52, 255), 0.5)
_grid_pen_l = QtGui.QPen(QtGui.QColor(22, 22, 22, 255), 1.0)
_grid_size_fine = 15
_grid_size_course = 150
_mouse_wheel_zoom_rate = 0.0015
request_node = QtCore.Signal(str)
def __init__(self, parent):
super(View, self).__init__(parent)
self.setRenderHint(QtGui.QPainter.Antialiasing)
self._manipulationMode = 0
gl_format = QtGui.QSurfaceFormat()
gl_format.setSamples(10)
QtGui.QSurfaceFormat.setDefaultFormat(gl_format)
gl_widget = QtOpenGLWidgets.QOpenGLWidget()
self.currentScale = 1
self._pan = False
self._pan_start_x = 0
self._pan_start_y = 0
self._numScheduledScalings = 0
self.lastMousePos = QtCore.QPoint()
self.setViewport(gl_widget)
self.setTransformationAnchor(QtWidgets.QGraphicsView.AnchorUnderMouse)
self.setResizeAnchor(QtWidgets.QGraphicsView.AnchorUnderMouse)
self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.setFrameShape(QtWidgets.QFrame.NoFrame)
def wheelEvent(self, event):
# sometimes you can triger the wheen when panning so we disable when panning
if self._pan:
return
num_degrees = event.delta() / 8.0
num_steps = num_degrees / 5.0
self._numScheduledScalings += num_steps
# If the user moved the wheel another direction, we reset previously scheduled scalings
if self._numScheduledScalings * num_steps < 0:
self._numScheduledScalings = num_steps
self.anim = QtCore.QTimeLine(350)
self.anim.setUpdateInterval(20)
self.anim.valueChanged.connect(self.scaling_time)
self.anim.finished.connect(self.anim_finished)
self.anim.start()
def scaling_time(self, x):
factor = 1.0 + self._numScheduledScalings / 300.0
self.currentScale *= factor
self.scale(factor, factor)
def anim_finished(self):
if self._numScheduledScalings > 0:
self._numScheduledScalings -= 1
else:
self._numScheduledScalings += 1
def drawBackground(self, painter, rect):
painter.fillRect(rect, self._background_color)
left = int(rect.left()) - (int(rect.left()) % self._grid_size_fine)
top = int(rect.top()) - (int(rect.top()) % self._grid_size_fine)
# Draw horizontal fine lines
gridLines = []
painter.setPen(self._grid_pen_s)
y = float(top)
while y < float(rect.bottom()):
gridLines.append(QtCore.QLineF(rect.left(), y, rect.right(), y))
y += self._grid_size_fine
painter.drawLines(gridLines)
# Draw vertical fine lines
gridLines = []
painter.setPen(self._grid_pen_s)
x = float(left)
while x < float(rect.right()):
gridLines.append(QtCore.QLineF(x, rect.top(), x, rect.bottom()))
x += self._grid_size_fine
painter.drawLines(gridLines)
# Draw thick grid
left = int(rect.left()) - (int(rect.left()) % self._grid_size_course)
top = int(rect.top()) - (int(rect.top()) % self._grid_size_course)
# Draw vertical thick lines
gridLines = []
painter.setPen(self._grid_pen_l)
x = left
while x < rect.right():
gridLines.append(QtCore.QLineF(x, rect.top(), x, rect.bottom()))
x += self._grid_size_course
painter.drawLines(gridLines)
# Draw horizontal thick lines
gridLines = []
painter.setPen(self._grid_pen_l)
y = top
while y < rect.bottom():
gridLines.append(QtCore.QLineF(rect.left(), y, rect.right(), y))
y += self._grid_size_course
painter.drawLines(gridLines)
return super(View, self).drawBackground(painter, rect)
def contextMenuEvent(self, event):
cursor = QtGui.QCursor()
# origin = self.mapFromGlobal(cursor.pos())
pos = self.mapFromGlobal(cursor.pos())
item = self.itemAt(event.pos())
if item:
if isinstance(item, Node):
print("Found Node", item)
menu = QtWidgets.QMenu(self)
hello_action = QtWidgets.QAction("Hello", self)
menu.addAction(hello_action)
action = menu.exec_(self.mapToGlobal(pos))
if action == hello_action:
print("Hello")
def dragEnterEvent(self, e):
if e.mimeData().hasFormat("text/plain"):
e.accept()
else:
e.ignore()
def dropEvent(self, e):
drop_node_name = e.mimeData().text()
self.request_node.emit(drop_node_name)
def mousePressEvent(self, event):
if event.button() == QtCore.Qt.MiddleButton:
self._pan = True
self._pan_start_x = event.x()
self._pan_start_y = event.y()
self.setCursor(QtCore.Qt.ClosedHandCursor)
return super(View, self).mousePressEvent(event)
def mouseReleaseEvent(self, event):
if event.button() == QtCore.Qt.MiddleButton:
self._pan = False
self.setCursor(QtCore.Qt.ArrowCursor)
return super(View, self).mouseReleaseEvent(event)
def mouseMoveEvent(self, event):
if self._pan:
self.horizontalScrollBar().setValue(
self.horizontalScrollBar().value() - (event.x() - self._pan_start_x)
)
self.verticalScrollBar().setValue(
self.verticalScrollBar().value() - (event.y() - self._pan_start_y)
)
self._pan_start_x = event.x()
self._pan_start_y = event.y()
return super(View, self).mouseMoveEvent(event)
