falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
7027 Commits
17 Branches
1.0GB
Tree: e5ab114eef
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'e5ab114eef'
${ noResults }
Carla/source/frontend/widgets/scalabledial.py

909 lines
39KB
Raw Blame History 

  1. #!/usr/bin/env python3

  2. # SPDX-FileCopyrightText: 2011-2024 Filipe Coelho <falktx@falktx.com>

  3. # SPDX-License-Identifier: GPL-2.0-or-later

  4. 

  5. # ---------------------------------------------------------------------------------------------------------------------

  6. # Imports (Global)

  7. 

  8. from math import cos, floor, pi, sin

  9. import ast

  10. 

  11. from qt_compat import qt_config

  12. 

  13. if qt_config == 5:

  14.     from PyQt5.QtCore import pyqtSlot, Qt, QEvent, QPoint, QPointF, QRectF, QTimer, QSize

  15.     from PyQt5.QtGui import QColor, QLinearGradient, QRadialGradient, QConicalGradient, QFontMetrics, QPen, QPolygonF

  16.     from PyQt5.QtWidgets import QToolTip

  17. elif qt_config == 6:

  18.     from PyQt6.QtCore import pyqtSlot, Qt, QEvent, QPoint, QPointF, QRectF, QTimer, QSize

  19.     from PyQt6.QtGui import QColor, QLinearGradient, QRadialGradient, QConicalGradient, QFontMetrics, QPen, QPolygonF

  20.     from PyQt6.QtWidgets import QToolTip

  21. 

  22. from .commondial import CommonDial

  23. from carla_shared import fontMetricsHorizontalAdvance, RACK_KNOB_GAP

  24. from carla_backend import (

  25.     PARAMETER_NULL,

  26.     PARAMETER_DRYWET,

  27.     PARAMETER_VOLUME,

  28.     PARAMETER_BALANCE_LEFT,

  29.     PARAMETER_BALANCE_RIGHT,

  30.     PARAMETER_PANNING,

  31.     PARAMETER_FORTH,

  32.     PARAMETER_MAX )

  33. 

  34. # ---------------------------------------------------------------------------------------------------------------------

  35. # Widget Class

  36. 

  37. class ScalableDial(CommonDial):

  38.     def __init__(self, parent, index,

  39.                                precision,

  40.                                default,

  41.                                minimum,

  42.                                maximum,

  43.                                label,

  44.                                paintMode,

  45.                                colorHint    = -1,        # Hue & Sat, -1 = NotColorable

  46.                                unit         = "%",       # Measurement Unit

  47.                                skinStyle    = "default", # Full name (from full list)

  48.                                whiteLabels  = 1,         # Is light/white theme?

  49.                                tweaks       = {},

  50.                                isInteger    = 0,         # Input is Integer

  51.                                isButton     = 0,         # Integer i/o is Button or LED

  52.                                isOutput     = 0,

  53.                                isVuOutput   = 0,         # Output is analog VU meter

  54.                                isVisible    = 1 ):

  55. 

  56.         # self.fWidth = self.fHeight = 32 # aka fImageBaseSize, not includes label.

  57.         CommonDial.__init__(self, parent, index, precision, default, minimum, maximum, label, paintMode, colorHint, unit, skinStyle, whiteLabels, tweaks, isInteger, isButton, isOutput, isVuOutput, isVisible)

  58. 

  59.     # FIXME not every repaint need to re-calculate geometry?

  60.     def updateSizes(self):

  61.         knownModes = [

  62.             # default

  63.             self.CUSTOM_PAINT_MODE_NULL          , #  0

  64.             self.CUSTOM_PAINT_MODE_CARLA_WET     , #  1

  65.             self.CUSTOM_PAINT_MODE_CARLA_VOL     , #  2

  66.             self.CUSTOM_PAINT_MODE_CARLA_L       , #  3

  67.             self.CUSTOM_PAINT_MODE_CARLA_R       , #  4

  68.             self.CUSTOM_PAINT_MODE_CARLA_PAN     , #  5

  69.             self.CUSTOM_PAINT_MODE_CARLA_FORTH   , #  6

  70.             self.CUSTOM_PAINT_MODE_CARLA_WET_MINI, #  9

  71.             self.CUSTOM_PAINT_MODE_CARLA_VOL_MINI, # 10

  72.             # calf

  73.             16,

  74.             # openav

  75.             32, 33, 34, 37, 38,

  76.             # zynfx

  77.             48, 49, 50, 53, 54,

  78.             # tube

  79.             64, 65, 66, 69, 70,

  80.         ]

  81. 

  82.         index = -1

  83.         for i in range(len(knownModes)):

  84.             if knownModes[i] == self.fCustomPaintMode:

  85.                 index = i

  86.                 break

  87. 

  88.         if (index == -1):

  89.             print("Unknown paint mode "+ str(self.fCustomPaintMode))

  90.             return

  91. 

  92.         self.skin    = int(self.fCustomPaintMode / 16)

  93.         self.subSkin = int(self.fCustomPaintMode % 16)

  94. 

  95.         width, hueA, hueB, travel, radius, size, point, labelLift = [

  96.             # default   Aqua

  97.             [ 32, 0.50, 0.50, 260, 10, 10, 3  , 1/2, ],

  98.             [ 32, 0.3 , 0.50, 260, 10, 10, 3  , 1/2, ], # WET

  99.             [ 32, 0.50, 0.50, 260, 10, 10, 3  , 1/2, ], # VOL

  100.             [ 26, 0.21, 0.21, 260,  8, 10, 2.5, 1/2, ], # L

  101.             [ 26, 0.21, 0.21, 260,  8, 10, 2.5, 1/2, ], # R

  102.             [ 32, 0.50, 0.50, 260, 10, 10, 3  , 1/2, ], # PAN

  103.             [ 32, 0.50, 0.50, 260, 10, 10, 3  , 1/2, ], # FORTH

  104.             [ 28, 0.3 , 0.50, 260,  9, 10, 2.5, 1/2, ], # WET_MINI

  105.             [ 28, 0.50, 0.50, 260,  9, 10, 2.5, 1/2, ], # VOL_MINI

  106.             # calf      Blue

  107.             [ 40, 0.53, 0.53, 290, 12, 12, 4  , 1  , ], # calf absent any wet/vol knobs

  108.             # openav   Orange

  109.             [ 32, 0.05, 0.05, 270, 12, 12, 2.5, 2/3, ],

  110.             [ 32, 0.30, 0.5,  270, 12, 12, 2.5, 2/3, ], # WET

  111.             [ 32, 0.5,  0.5,  270, 12, 12, 2.5, 2/3, ], # VOL

  112.             [ 32, 0.5,  0.5,  270, 12, 12, 2.5, 2/3, ],

  113.             [ 32, 0.5,  0.5,  270, 12, 12, 2.5, 2/3, ],

  114.             # zynfx     Teal

  115.             [ 38, 0.55, 0.55, 264, 12, 12, 4  , 1/4, ],

  116.             [ 38, 0.30, 0.5,  264, 12, 12, 4  , 1/4, ], # WET

  117.             [ 38, 0.5,  0.5,  264, 12, 12, 4  , 1/4, ], # VOL

  118.             [ 38, 0.5,  0.5,  264, 12, 12, 4  , 1/4, ],

  119.             [ 38, 0.5,  0.5,  264, 12, 12, 4  , 1/4, ],

  120.             # tube      VFD

  121.             [ 50, 0.45, 0.45, 258, 12, 12, 4  , 1/2, ],

  122.             [ 50, 0.45, 0.45, 258, 12, 12, 4  , 1/2, ], # WET

  123.             [ 50, 0.45, 0.45, 258, 12, 12, 4  , 1/2, ], # VOL

  124.             [ 50, 0.45, 0.45, 258, 12, 12, 4  , 1/2, ],

  125.             [ 50, 0.45, 0.45, 258, 12, 12, 4  , 1/2, ],

  126.         ] [index]

  127. 

  128.         #  Geometry & Color of controls & displays, some are tweakable:

  129.         # 1. Try to get value from per-skin tweak;

  130.         # 2. Then try to get value from common tweak;

  131.         # 3. Then use default value from array.

  132.         self.fWidth = self.fHeight = width

  133. 

  134.         # Angle span (travel)

  135.         # calf must be 360/36*29=290

  136.         # tube must be 360/14*10=257.14 or 360/12*10=300

  137.         self.fTravel = int(self.getTweak('KnobTravel', travel))

  138. 

  139.         # Radius of some notable element of Knob (not exactly the largest)

  140.         self.fRadius = int(self.getTweak('KnobRadius', radius))

  141. 

  142.         # Size of Button (half of it, similar to "raduis")

  143.         self.fSize = int(self.getTweak('ButtonSize', size))

  144. 

  145.         # Point, line or other accent on knob

  146.         self.fPointSize = point

  147. 

  148.         # Colouring, either only one or both values can be used for skin.

  149.         if (self.subSkin > 0) or (self.skin in (1, 3, 4,)) :

  150.             self.fHueA = hueA

  151.             self.fHueB = hueB

  152.         # default and openav can be re-colored

  153.         elif self.colorFollow:

  154.             self.fHueA = self.fHueB = int(self.fColorHint) / 100.0  # we use hue only yet

  155.         else:

  156.             # NOTE: here all incoming color data, except hue, is lost.

  157.             self.fHueA = self.fHueB = self.fCustomPaintColor.hueF()

  158. 

  159. 

  160.         metrics = QFontMetrics(self.fLabelFont)

  161. 

  162.         if not self.fLabel:

  163.             self.fLabelWidth = 0

  164.         else:

  165.             self.fLabelWidth = fontMetricsHorizontalAdvance(metrics, self.fLabel)

  166. 

  167.         extraWidthAuto = max((self.fLabelWidth - self.fWidth), 0)

  168. 

  169.         self.fLabelHeight = metrics.height()

  170. 

  171.         if (self.fCustomPaintMode % 16) == 0: # exclude: DryWet, Volume, etc.

  172.             extraWidth = int(self.getTweak('GapMin', 0))

  173.             extraWidthLimit = int(self.getTweak('GapMax', 0))

  174. 

  175.             if self.getTweak('GapAuto', 0):

  176.                 extraWidth = max(extraWidth, extraWidthAuto)

  177. 

  178.             extraWidth = min(extraWidth, extraWidthLimit)

  179. 

  180.             self.fWidth = self.fWidth + extraWidth

  181. 

  182.         self.setMinimumSize(self.fWidth, self.fHeight + self.fLabelHeight + RACK_KNOB_GAP)

  183.         self.setMaximumSize(self.fWidth, self.fHeight + self.fLabelHeight + RACK_KNOB_GAP)

  184. 

  185.         if not self.fLabel:

  186.             self.fLabelHeight = 0

  187.             # self.fLabelWidth  = 0

  188.             return

  189. 

  190.         self.fLabelPos.setX(float(self.fWidth)/2.0 - float(self.fLabelWidth)/2.0)

  191. 

  192.         # labelLift = (1/2, 1, 2/3, 1/4, 1/2, 1, 1, 1)[skin % 8]

  193.         self.fLabelPos.setY(self.fHeight + self.fLabelHeight * labelLift)

  194. 

  195.         # jpka: TODO Can't see how gradients work, looks like it's never triggered.

  196.         self.fLabelGradient.setStart(0, float(self.fHeight)/2.0)

  197.         self.fLabelGradient.setFinalStop(0, self.fHeight + self.fLabelHeight + 5)

  198. 

  199.         self.fLabelGradientRect = QRectF(float(self.fHeight)/8.0, float(self.fHeight)/2.0,

  200.                                          float(self.fHeight*3)/4.0, self.fHeight+self.fLabelHeight+5)

  201. 

  202.     def setImage(self, imageId):

  203.         print("Loopback for self.setupZynFxParams(), FIXME!")

  204.         return

  205. 

  206.     def minimumSizeHint(self):

  207.         return QSize(self.fWidth, self.fHeight)

  208. 

  209.     def sizeHint(self):

  210.         return QSize(self.fWidth, self.fHeight)

  211. 

  212.     # def changeEvent(self, event):

  213.     #     CommonDial.changeEvent(self, event)

  214.     #

  215.     #     # Force svg update if enabled state changes

  216.     #     if event.type() == QEvent.EnabledChange:

  217.     #         self.slot_updateImage()

  218. 

  219.     def drawMark(self, painter, X, Y, r1, r2, angle, width, color):

  220.         A = angle * pi/180

  221.         x = X + r1 * cos(A)

  222.         y = Y - r1 * sin(A)

  223.         painter.setPen(QPen(color, width, cap=Qt.RoundCap))

  224.         if not (r1 == r2):  # line

  225.             x1 = X + r2 * cos(A)

  226.             y1 = Y - r2 * sin(A)

  227.             painter.drawLine(QPointF(x, y), QPointF(x1, y1))

  228.         else:               # ball

  229.             painter.drawEllipse(QRectF(x-width/2, y-width/2, width, width))

  230. 

  231.     gradMachined = {5.9, 10.7, 15.7, 20.8, 25.8, 30.6, 40.6, 45.9,

  232.                    55.9, 60.7, 65.7, 70.8, 75.8, 80.6, 90.6, 95.9}

  233. 

  234.     def grayGrad(self, painter, X, Y, a, b, gradPairs, alpha = 1.0):

  235.         if b == -1:

  236.             grad = QConicalGradient(X, Y, a)

  237.         elif b == -2:

  238.             grad = QRadialGradient (X, Y, a)

  239.         else:

  240.             grad = QLinearGradient (X, Y, a, b)

  241. 

  242.         for i in gradPairs:

  243.             grad.setColorAt(int(i)/100.0, QColor.fromHslF(0, 0, (i % 1.0), alpha))

  244. 

  245.         return grad

  246. 

  247.     # Pen is always full opacity (alpha = 1)

  248.     def grayGradPen(self, painter, X, Y, a, b, gradPairs = {0.10, 50.30, 100.10}, width = 1.0):

  249.         painter.setPen(QPen(self.grayGrad(painter, X, Y, a, b, gradPairs, 1), width, Qt.SolidLine, Qt.FlatCap))

  250. 

  251.     def grayGradBrush(self, painter, X, Y, a, b, gradPairs, alpha = 1.0):

  252.         painter.setBrush(self.grayGrad(painter, X, Y, a, b, gradPairs, alpha))

  253. 

  254. 

  255.     # Replace Qt draw over substrate bitmap or svg to

  256.     # all-in-one widget generated from stratch using Qt only,

  257.     # make it highly tuneable, and uniformly look like

  258.     # using HSL color model to make same brightness of colored things.

  259.     # We can also easily have color tinted (themed) knobs.

  260.     # Some things were simplified a little, to gain more speed.

  261.     # R: knob nib (cap) radius

  262.     def paintDial(self, painter, X, Y, H, S, L, E, normValue, enabled):

  263.         R = self.fRadius

  264.         barWidth = self.fPointSize

  265.         angleSpan = self.fTravel

  266. 

  267.         hueA = self.fHueA

  268.         hueB = self.fHueB

  269. 

  270.         color0  = QColor.fromHslF(hueA, S, L,        1)

  271.         color0a = QColor.fromHslF(hueA, S, L/2-0.25, 1)

  272.         color1  = QColor.fromHslF(hueB, S, L,        1)

  273. 

  274.         skin = self.skin

  275. 

  276.         def ang(value):

  277.             return angleSpan * (0.5 - value) + 90

  278. 

  279.         def drawArcV(rect, valFrom, valTo, ticks = 0):

  280.             # discretize scale: for 10 points, first will lit at 5%,

  281.             # then 15%, and last at 95% of normalized value,

  282.             # i.e. treshold is: center of point exactly matches knob mark angle

  283.             if ticks:

  284.                 valTo = int(valTo * (ticks * angleSpan / 360) + 0.5) / (ticks * angleSpan / 360)

  285. 

  286.             painter.drawArc(rect, int(ang(valFrom) * 16), int((ang(valTo) - ang(valFrom)) * 16))

  287. 

  288.         def squareBorder(w):

  289.             return QRectF(X-R-w, Y-R-w, (R+w)*2, (R+w)*2)

  290. 

  291.         def gray(luma):

  292.             return QColor.fromHslF(0, 0, luma, 1)

  293. 

  294. 

  295.         # Knob light arc "base" (starting) value/angle.

  296.         if self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_CARLA_L:

  297.             refValue = 0

  298.         elif self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_CARLA_R:

  299.             refValue = 1

  300.         elif (self.fMinimum == -self.fMaximum) and (skin == 0):

  301.             refValue = 0.5

  302.         else:

  303.             refValue = 0

  304. 

  305.         knobMuted = (self.knobPusheable and (normValue == refValue))

  306. 

  307.         haveLed = self.getTweak('WetVolPushLed', 1) and self.fCustomPaintMode in (1, 2, 5, 6, 9, 10,)

  308. 

  309.         if self.fIndex in (PARAMETER_DRYWET, PARAMETER_VOLUME, PARAMETER_PANNING, PARAMETER_FORTH): # -3, -4, -7, -9

  310.             if knobMuted:

  311.                 if self.fIndex == PARAMETER_DRYWET:

  312.                     self.pushLabel("Thru")

  313.                 elif self.fIndex == PARAMETER_VOLUME:

  314.                     self.pushLabel("Mute")

  315.                 elif self.fIndex == PARAMETER_PANNING:

  316.                     self.pushLabel("Center")

  317.                 else:

  318.                     self.pushLabel("Midway")

  319.             else:

  320.                 self.popLabel()

  321. 

  322.         if skin == 0: # mimic svg dial

  323.             # if not knobMuted:

  324.             if not (knobMuted and haveLed):

  325.                 # light arc substrate: near black, 0.5 px exposed

  326.                 painter.setPen(QPen(gray(0.10), barWidth+1, cap=Qt.FlatCap))

  327.                 drawArcV(squareBorder(barWidth), 0, 1)

  328. 

  329.                 # light arc: gray bar

  330.                 # should be combined with light (value) arc to be a bit faster ?

  331.                 self.grayGradPen(painter, X, Y, 270, -1, {0.20, 100.15}, barWidth)

  332.                 drawArcV(squareBorder(barWidth), 0, 1)

  333. 

  334.             # cap

  335.             self.grayGradBrush(painter, X-R, Y-R, R*2, -2, {0.45+E, 100.15+E})

  336.             painter.setPen(QPen(gray(0.10), 0.5))

  337.             painter.drawEllipse(squareBorder(1))

  338. 

  339.         elif skin == 1: # calf

  340.             # outer chamfer & leds substrate

  341.             self.grayGradPen(painter, X, Y, 135, -1, {0.15, 50.50, 100.15}, 1.5)

  342.             painter.setBrush(color0a)

  343.             painter.drawEllipse(squareBorder(barWidth*2-1))

  344. 

  345.             # machined shiny cap with chamfer

  346.             self.grayGradPen(painter, X, Y, -45, -1, {0.15, 50.50, 100.15})

  347.             self.grayGradBrush(painter, X, Y, 0, -1, self.gradMachined)

  348.             painter.drawEllipse(squareBorder(1))

  349. 

  350.         elif skin == 2: # openav

  351.             # light arc substrate

  352.             painter.setPen(QPen(gray(0.20+E), barWidth))

  353.             drawArcV(squareBorder(barWidth), 0, 1)

  354. 

  355.         elif skin == 3: # zynfx

  356.             # light arc substrate

  357.             painter.setPen(QPen(QColor.fromHslF(0.57, 0.8, 0.25, 1), barWidth+2, cap=Qt.FlatCap))

  358.             drawArcV(squareBorder(barWidth), 0, 1)

  359. 

  360.             # cap

  361.             painter.setPen(QPen(gray(0.0), 1))

  362.             painter.setBrush(gray(0.3 + E))

  363.             painter.drawEllipse(squareBorder(-2))

  364. 

  365.         # These knobs are different for integers and for floats.

  366.         elif skin == 4: # tube / bakelite

  367.             chamfer = 1.5 # It is best when 1.5 at normal zoom, and 1.0 for >2x HiDpi

  368.             # base

  369.             self.grayGradPen(painter, X, Y, -45, -1, width=chamfer)

  370.             self.grayGradBrush(painter, X-5-ang(normValue)/36, -20, 83, -2, {0.2, 50.2, 51.00, 100.00})

  371.             if self.fIsInteger: # chickenhead knob: small base

  372.                 painter.drawEllipse(squareBorder(1))

  373.             else:               # round knob: larger base

  374.                 painter.drawEllipse(squareBorder(R*0.7))

  375. 

  376.             polygon = QPolygonF()

  377.             # "chickenhead" pointer

  378.             if self.fIsInteger:

  379.                 for i in range(17):

  380.                     A = ((0.01, 0.02, 0.03, 0.06, 0.2, 0.3, 0.44, 0.455, -0.455, -0.44, -0.3, -0.2, -0.06, -0.03, -0.02, -0.01, 0.01)[i] * 360 - ang(normValue)) * pi/180

  381.                     r =  (1,    0.97, 0.91, 0.7,  0.38, 0.39, 0.87, 0.9,   0.9, 0.87, 0.39, 0.38, 0.7, 0.91, 0.97, 1, 1)[i] * R

  382.                     polygon.append(QPointF(X + r * 1.75 * cos(A), Y + r * 1.75 * sin(A)))

  383.             # 8-teeth round knob outline

  384.             else:

  385.                 for i in range(64):

  386.                     A = (i / 64 * 360 - ang(normValue)) * pi/180

  387.                     r = R * (1, 0.95, 0.91, 0.89, 0.88, 0.89, 0.91, 0.95)[i % 8]

  388.                     polygon.append(QPointF(X + r * 1.5 * cos(A), Y + r * 1.5 * sin(A)))

  389. 

  390.             self.grayGradPen(painter, X, Y, -45, -1, {0.10, 50.50, 100.10}, chamfer)

  391.             self.grayGradBrush(painter, X-5-ang(normValue)/36, -20, 75, -2, {0.2, 50.2, 51.00, 100.00})

  392.             painter.drawPolygon(polygon)

  393. 

  394.             # machined shiny penny with chamfer

  395.             self.grayGradPen(painter, X, Y, 135, -1, {0.15, 50.50, 100.15})

  396.             self.grayGradBrush(painter, X, Y, -ang(normValue)/36, -1, self.gradMachined, 0.75)

  397.             if self.fIsInteger: # chickenhead knob: small circle

  398.                 painter.drawEllipse(squareBorder(-R*0.65))

  399.             else:               # round knob: large one

  400.                 painter.drawEllipse(squareBorder(-1))

  401. 

  402.             # Outer scale marks

  403.             for i in range(0, 11):

  404.                 angle = ((0.5-i/10) * angleSpan + 90)

  405.                 self.drawMark(painter, X, Y, R*2, R*2, angle, barWidth/12 * (4 + 1 * int((i % 10) == 0)), gray(0.5 + E))

  406. 

  407.         # if knobMuted:

  408.         if (knobMuted and haveLed):

  409.             # if self.getTweak('WetVolPushLed', 1):

  410.             self.drawMark(painter, X, Y, 0, 0, 0, barWidth, color0)

  411.             return

  412. 

  413.         # draw arc: forward, or reverse (for 'R' ch knob)

  414.         if (not (normValue == refValue)) and (not (skin == 4)):

  415. 

  416.             gradient = QConicalGradient(X, Y, 270)

  417.             cap=Qt.FlatCap

  418. 

  419.             if not (skin == 1): # any, except calf

  420.                 ticks = 0

  421.                 gradient.setColorAt(0.75, color0)

  422.                 gradient.setColorAt(0.25, color1)

  423.                 if skin == 3: # zynfx

  424.                     # light arc partial (angled) black substrate

  425.                     painter.setPen(QPen(gray(0.0), barWidth+2, cap=Qt.FlatCap))

  426.                     drawArcV(squareBorder(barWidth), refValue-0.013, normValue+0.013)

  427.                 elif skin == 2: # openav

  428.                     cap=Qt.RoundCap

  429.             else: # calf

  430.                 ticks = 36

  431.                 for i in range(2, ticks-2, 1):

  432.                     gradient.setColorAt((i+0.5-0.35)/ticks, color0)

  433.                     gradient.setColorAt((i+0.5)    /ticks, Qt.black)

  434.                     gradient.setColorAt((i+0.5+0.35)/ticks, color0)

  435. 

  436.             painter.setPen(QPen(gradient, barWidth, Qt.SolidLine, cap))

  437.             drawArcV(QRectF(squareBorder(barWidth)), refValue, normValue, ticks)

  438. 

  439.         # do not draw marks on disabled items

  440.         if not enabled:

  441.             return

  442. 

  443.         A = ang(normValue)

  444. 

  445.         match skin:

  446.             case 0: # ball

  447.                 self.drawMark(painter, X, Y, R*0.8, R*0.8, A, barWidth/2+0.5, color0)

  448.             case 1: # line for calf

  449.                 self.drawMark(painter, X, Y, R*0.6, R*0.9, A, barWidth/2, Qt.black)

  450.             case 2: # line for openav

  451.                 self.drawMark(painter, X, Y, 0, R+barWidth, A, barWidth, color0)

  452.             case 3: # line for zynfx

  453.                 self.drawMark(painter, X, Y, 2, R-3, A, barWidth/2+0.5, Qt.white)

  454.             case 4: # ball

  455.                 r = R * (int(self.fIsInteger) * 0.25 + 1.2)

  456.                 self.drawMark(painter, X, Y, r, r, A, barWidth/2+0.5, Qt.white)

  457. 

  458. 

  459.     def paintButton(self, painter, X, Y, H, S, L, E, normValue, enabled):

  460.         # W: button cap half-size ; w: bar width

  461.         W = self.fRadius

  462.         w = self.fPointSize

  463. 

  464.         hue = self.fHueA

  465. 

  466.         skin = int(self.fCustomPaintMode / 16)

  467. 

  468.         def squareBorder(w, dw=0):

  469.             return QRectF(X-W-w-dw, Y-W-w, (W+w+dw)*2, (W+w)*2)

  470. 

  471.         def gray(luma):

  472.             return QColor.fromHslF(0, 0, luma, 1)

  473. 

  474.         color = QColor.fromHslF(hue, S, L, 1)

  475. 

  476.         centerLed = self.getTweak('ButtonHaveLed', 0) # LED itself & size increase

  477.         coloredNeon = self.getTweak('ColoredNeon', 1) # But worse when HighContrast.

  478. 

  479.         if skin == 0: # internal

  480.             if not centerLed:

  481.                 # light bar substrate: near black, 0.5 px exposed

  482.                 painter.setPen(QPen(gray(0.10), w+1))

  483.                 painter.drawLine(QPointF(X-W/2, Y-W-w), QPointF(X+W/2, Y-W-w))

  484. 

  485.                 # light bar: gray bar

  486.                 painter.setPen(QPen(gray(0.20), w))

  487.                 painter.drawLine(QPointF(X-W/2, Y-W-w), QPointF(X+W/2, Y-W-w))

  488. 

  489.             # cap

  490.             self.grayGradBrush(painter, X-W/2, Y-W/2, W*2, -2, {0.13+E, 50.18+E, 100.35+E})

  491.             painter.setPen(QPen(gray(0.05), 1))

  492.             # A bit larger buttons when no top LED, but centered one.

  493.             painter.drawRoundedRect(squareBorder(-1+centerLed), 3, 3)

  494. 

  495.         elif skin == 1: # calf

  496.             # outer chamfer & leds substrate

  497.             self.grayGradPen(painter, X, Y, 135, -1, {24.25, 26.50, 76.50, 78.25}, 1.5)

  498.             painter.setBrush(QColor.fromHslF(hue, S, 0.05+E/2, 1))

  499.             painter.drawRoundedRect(QRectF(X-W-1, Y-W-w-0-1, W*2+2, W*2+w+0+2), 4, 4)

  500. 

  501.             # machined shiny cap with chamfer

  502.             self.grayGradPen(painter, X, Y, -45, -1, {24.25, 26.50, 74.50, 76.25})

  503.             self.grayGradBrush(painter, X, Y, -30, -1, self.gradMachined)

  504.             painter.drawRoundedRect(squareBorder(-1), 3, 3)

  505. 

  506.         elif skin == 2: # openav

  507.             # light substrate

  508.             pen = QPen(gray(0.20+E), w)

  509.             painter.setPen(pen)

  510.             painter.drawRoundedRect(squareBorder(0), 3, 3)

  511. 

  512.         elif skin == 3: # zynfx

  513.             if not centerLed:

  514.                 # light bar substrate: teal, 1 px exposed

  515.                 painter.setPen(QPen(QColor.fromHslF(hue, 0.8, 0.25, 1), w+2))

  516.                 painter.drawLine(QPointF(X-W/2, Y-W-w), QPointF(X+W/2, Y-W-w))

  517. 

  518.             # button

  519.             painter.setPen(QPen(gray(0.0), 1))

  520.             painter.setBrush(gray(0.3 + E))

  521.             painter.drawRoundedRect(squareBorder(-2, 4), 3, 3)

  522. 

  523.         elif skin == 4: # tube

  524.             # bakelite cap

  525.             self.grayGradPen(painter, X, Y, -45, -1)

  526.             self.grayGradBrush(painter, X-10, -40, 120, -2, {0.2, 50.2, 51.00, 100.00})

  527.             painter.drawRoundedRect(squareBorder(W*0.2), 3, 3)

  528. 

  529.             # neon lamp

  530.             if (normValue > 0):

  531.                 grad = QRadialGradient(X, Y, 10)

  532.                 for i in ({0.6, 20.6, 70.4, 100.0}):

  533.                     if coloredNeon:

  534.                         grad.setColorAt(int(i)/100.0, QColor.fromHslF((0.05 - normValue) % 1.0, S, (i % 1.0), 1))

  535.                     else:

  536.                         grad.setColorAt(int(i)/100.0, QColor.fromHslF(0.05, S, (i % 1.0) * normValue, 1))

  537. 

  538.                 painter.setPen(QPen(Qt.NoPen))

  539.                 painter.setBrush(grad)

  540.                 painter.drawRoundedRect(squareBorder(-W*0.4), 1.5, 1.5)

  541. 

  542.             # glass over neon lamp

  543.             self.grayGradPen(painter, X, Y, 135, -1)

  544.             self.grayGradBrush(painter, X-10, -40, 124, -2, {0.9, 50.9, 51.4, 100.4}, 0.25)

  545.             painter.drawRoundedRect(squareBorder(-W*0.4), 1.5, 1.5)

  546. 

  547.         # draw active lights

  548.         if skin == 0:  # internal

  549.             if not centerLed:

  550.                 if (normValue > 0):

  551.                     painter.setPen(QPen(color, w))

  552.                     if (normValue < 1):

  553.                         painter.drawLine(QPointF(X-W/2, Y-W-w), QPointF(X-w/2, Y-W-w))

  554.                     else:

  555.                         painter.drawLine(QPointF(X-W/2, Y-W-w), QPointF(X+W/2, Y-W-w))

  556.             else:

  557.                 painter.setPen(QPen(gray(0.05), 0.5))

  558.                 painter.setBrush(color.darker(90 + int(300*(1-normValue))))

  559.                 painter.drawRoundedRect(squareBorder(w-W), 1, 1)

  560. 

  561.         elif skin == 1: # calf

  562.             if (normValue > 0):

  563.                 grad = QLinearGradient(X-W, Y, X+W, Y)

  564.                 for i in ({20.0, 45.6, 55.6, 80.0} if (normValue < 1)

  565.                             else {0.0, 30.6, 40.5, 45.7, 55.7, 60.5, 70.6, 100.0}):

  566.                     grad.setColorAt(int(i)/100.0, QColor.fromHslF(hue, S, (i % 1)+E, 1))

  567.                 painter.setPen(QPen(grad, w-0.5, cap=Qt.FlatCap))

  568.                 painter.drawLine(QPointF(X-W, Y-W-w/2), QPointF(X+W, Y-W-w/2))

  569. 

  570.         elif skin == 2:  # openav

  571.             painter.setPen(QPen(color, w, cap=Qt.RoundCap))

  572.             if (normValue > 0):

  573.                 painter.drawRoundedRect(squareBorder(-W * (1 - normValue)), 3, 3)

  574.             else:

  575.                 painter.drawLine(QPointF(X-0.1, Y), QPointF(X+0.1, Y))

  576. 

  577.         elif skin == 3:  # zynfx

  578.             if not centerLed:

  579.                 if (normValue > 0):

  580.                     dx = (W - w) if (normValue < 1) else 0

  581.                     painter.setPen(QPen(gray(0), w+2))

  582.                     painter.drawLine(QPointF(X-W/2, Y-W-w), QPointF(X+W/2-dx, Y-W-w))

  583.                     painter.setPen(QPen(color, w))

  584.                     painter.drawLine(QPointF(X-W/2, Y-W-w), QPointF(X+W/2-dx, Y-W-w))

  585.             else:

  586.                 painter.setPen(QPen(gray(0), 1))

  587.                 painter.setBrush(color.darker(90 + int(300*(1-normValue))))

  588.                 painter.drawEllipse(squareBorder(w-W+1))

  589. 

  590.         # do not draw marks on disabled items

  591.         if not enabled:

  592.             return

  593. 

  594.         match skin:

  595.             case 0: # internal: ball at center

  596.                 if not centerLed:

  597.                     self.drawMark(painter, X, Y, 0, 0, 0, w/2+0.5, color)

  598.             # case 3: # openav

  599.             #     painter.setPen(QPen(color, w, cap=Qt.RoundCap))

  600.             #     painter.drawLine(QPointF(X-0.1, Y), QPointF(X+0.1, Y))

  601.             case 3: # zynfx: ball at center

  602.                 if not centerLed:

  603.                     self.drawMark(painter, X, Y, 0, 0, 0, w/2, gray(1))

  604. 

  605. 

  606.     # Just a text label not so good for fast updated display, see issue #1934.

  607.     # NOTE Work in progress.

  608.     def paintDisplay(self, painter, X, Y, H, S, L, E, normValue, enabled):

  609. 

  610.         # X, Y: Center of label.

  611.         def plotStr(self, painter, X, Y, st, fontSize, aspectRatio, skew):

  612. 

  613.             # Due to CPU/speed gain, we use simplest possible 7-segmented digits.

  614.             # Shape to Speed balance: Speed

  615.             h = ["KYNKNY ROZUZ RVKVY ROJUJ",    # 0        NJ RJ VJ

  616.                  "KYVJVQ RVSVZ",                # 1        NR RR VR

  617.                  "KYNJVJVRNRNZVZ",              # 2        NZ RZ VZ

  618.                  "KYNJVJVZNZ RVRNR",            # 3          P]

  619.                  "KYNJNRVR RVJVZ",              # 4

  620.                  "KYVJNJNRVRVZNZ",              # 5

  621.                  "KYVJNJNZVZVRNR",              # 6

  622.                  "KYNJVJVZ",                    # 7

  623.                  "KYNJNZVZVJNJ RNRVR",          # 8

  624.                  "KYNZVZVJNJNRVR",              # 9

  625.                  "KYNRVR",                      # -

  626.                  "OTRZP]",                      # .

  627.                  "KYNNNX RVPNTVX",              # k

  628.                  "KYNXNLRRVLVX"     ]           # M

  629. 

  630.             def plotHersheyChar(painter, X, Y, c, fontSize, aspectRatio, skew, justGetWidth):

  631.                 lm = (ord(h[c][0]) - ord('R')) * fontSize * aspectRatio

  632.                 rm = (ord(h[c][1]) - ord('R')) * fontSize * aspectRatio

  633.                 if justGetWidth:

  634.                     return X + rm - lm

  635. 

  636.                 points = []

  637.                 X = X - lm

  638.                 # The speed and CPU load is critical here.

  639.                 # I try to make it as efficient as possible, but can it be even faster?

  640.                 for i in range(1, int(len(h[c])/2)):

  641.                     a = (h[c][i*2])

  642.                     b = (h[c][i*2+1])

  643.                     if (a == ' ') and (b == 'R'):

  644.                         painter.drawPolyline(points)

  645.                         points = []

  646.                     else:

  647.                         y = (ord(b) - ord('R')) * fontSize

  648.                         x = (ord(a) - ord('R')) * fontSize * aspectRatio + skew * y

  649.                         points.append(QPointF(X+x, Y+y))

  650. 

  651.                 painter.drawPolyline(points)

  652.                 X = X + rm

  653.                 return X

  654. 

  655.             def plotDecodedChar(painter, X, Y, st, fontSize, aspectRatio, skew, justGetWidth):

  656.                 for i in range(len(st)):

  657.                     digit = "0123456789-.kM".find(st[i])

  658.                     if digit < 0:

  659.                         print("ERROR: Illegal char at " + str(i) + " in " + st)

  660.                     else:

  661.                         X = plotHersheyChar(painter, X, Y, digit, fontSize, aspectRatio, skew, justGetWidth)

  662.                 return X

  663. 

  664.             widthPx = plotDecodedChar(painter, 0, Y, st, fontSize, aspectRatio, skew, 1)

  665.             plotDecodedChar(painter, X-widthPx/2, Y, st, fontSize, aspectRatio, skew, 0)

  666.             return

  667. 

  668.         def strLimDigits(x):

  669.             s = str(x)

  670.             ret = lambda x: float(x) if '.' in s else int(x)

  671.             return str(ret(s[:max(s.find('.'), 4+1)].strip('.')))

  672. #            return str(ret(s[:max(s.find('.'), num+1 + ('-' in s))].strip('.')))

  673. 

  674.         def plotNixie(n):

  675.             painter.setPen(QPen(QColor.fromHslF(0.05, S, L, 1), 2.5, cap=Qt.RoundCap))

  676. 

  677.             # We use true arcs instead of polyline/Bezier.

  678.             # Arcs are perfectly matched with original tube.

  679.             # x = 0..20, y = 0..32

  680.             digits = [[[ 2,00,18,16, 480,2400],[   00,-8,48,40,2400,3360],

  681.                        [ 2,16,18,32,3360,5280],[  -28,-8,20,40,5280,6240]],  # 0

  682.                       [[10,00,10,32,   0,   0]],                             # 1

  683.                       [[ 1,-0.5,19,17.5,4608,8640],[1,17,30,46,1680,2880],

  684.                         [1,31.5,19,31.5,   0,   0]],                         # 2

  685.                       [[-2,10,20,32,3500,7300],[    2,00,19,00,   0,   0],

  686.                        [19,00, 8,10,   0,   0]],                             # 3

  687.                       [[ 1,22,17,00,   0,   0],[   17,00,17,32,   0,   0],

  688.                         [1,22,17,22,   0,   0]],                             # 4

  689.                       [[-1,12,19,32,3500,7920],[    4,00,18,00,   0,   0],

  690.                         [4,00, 2,14,   0,   0]],                             # 5

  691.                       [[00,12,20,32,   0,5760],[   0,-10,64,54,2150,2880]],  # 6

  692.                       [[ 1,00,19,00,   0,   0],[   19,00, 8,32,   0,   0]],  # 7

  693.                       [[ 1,14,19,32,   0,5760],[    3,00,17,14,   0,5760]],  # 8

  694.                       [[00,00,20,20,   0,5760],[ 20,42,-44,-22,5030,5760]]]  # 9

  695. 

  696.             for x0, y0, x1, y1, a0, a1 in digits[n]:

  697.                 if a0 == a1 == 0:

  698.                     painter.drawLine(QPointF(x0+X-10, y0+Y-16), QPointF(x1+X-10, y1+Y-16))

  699.                 else:

  700.                     rect = QRectF(x0+X-10, y0+Y-16, x1-x0, y1-y0)

  701.                     painter.drawArc(rect, a0, a1-a0)

  702. 

  703.         def squareBorder(w, dw=0):

  704.             return QRectF(X-W-w-dw, Y-W-w, (W+w+dw)*2, (W+w)*2)

  705. 

  706.         W = Y-1                             # "radius"

  707.         value = self.fRealValue

  708.         hue = self.fHueA

  709. 

  710.         # if self.fIsButton: # TODO make it separate paintLED

  711.         if (self.fIsInteger and (self.fMinimum == 0) and (self.fMaximum == 1)): # TODO

  712.             # Neon lamp

  713.             if (self.fCustomPaintMode == 64): # tube

  714.                 # bakelite lamp holder

  715.                 self.grayGradPen(painter, X, Y, -45, -1)

  716.                 self.grayGradBrush(painter, X-10, -40, 120, -2, {0.2, 50.2, 51.00, 100.00})

  717.                 painter.drawRoundedRect(squareBorder(-W*0.45), 3, 3)

  718. 

  719.                 # neon lamp

  720.                 if (normValue > 0):

  721.                     grad = QRadialGradient(X, Y, 13)

  722.                     for i in ({0.6, 20.6, 70.4, 100.0}):

  723.                         grad.setColorAt(int(i)/100.0, QColor.fromHslF(0.05, 1.0, (i % 1.0) * normValue, 1))

  724.                     painter.setPen(QPen(Qt.NoPen))

  725.                     painter.setBrush(grad)

  726.                     painter.drawRoundedRect(squareBorder(-W*0.6), 1.5, 1.5)

  727. 

  728.                 # glass over neon lamp

  729.                 self.grayGradPen(painter, X, Y, 135, -1)

  730.                 self.grayGradBrush(painter, X-10, -40, 124, -2, {0.9, 50.9, 51.4, 100.4}, 0.25)

  731.                 painter.drawRoundedRect(squareBorder(-W*0.6), 1.5, 1.5)

  732.                 return

  733. 

  734.             painter.setPen(QPen(QColor.fromHslF(0, 0, 0.3-0.15*normValue+E, 1), 1.5))

  735.             painter.setBrush(QColor(QColor.fromHslF(hue, S, L*(normValue*0.8+0.1), 1)))

  736.             painter.drawRoundedRect(squareBorder(-W/2-2), 1.5, 1.5)

  737.             return

  738. 

  739.         if (self.fCustomPaintMode == 64) and \

  740.         (self.fIsInteger and (self.fMinimum >= 0) and (self.fMaximum < 20)):

  741.             #Nixie tube for 0..9, or 1 1/2 tubes for 11..19

  742.             Y = Y - 2

  743.             self.grayGradPen(painter, X, Y, 135, -1)

  744.             self.grayGradBrush(painter, X-10, -40, 120, -2, {0.2, 50.2, 51.00, 100.00})

  745.             painter.drawRoundedRect(squareBorder(-2, -W*0.2), 3, 3)

  746. 

  747.             if (value < 10):

  748.                 plotNixie(int(value % 10))

  749.             else:

  750.                 if (value == 11):

  751.                     X = X + 8

  752.                     plotNixie(1)

  753.                 else:

  754.                     X = X + 4

  755.                     plotNixie(int(value % 10))

  756.                 X = X - 16

  757.                 plotNixie(1)

  758.             return

  759. 

  760.         # Will it be analog display, or digital 7-segment scale?

  761.         if not self.fIsVuOutput:

  762.             unit = ""

  763.             if abs(value) >= 10000.0:

  764.                 value = value / 1000.0

  765.                 unit = "k"

  766.             if abs(value) >= 10000.0:

  767.                 value = value / 1000.0

  768.                 unit = "M"

  769.             # Remove trailing decimal zero and decimal point also.

  770.             if (value % 1.0) == 0:

  771.                 value = int(value)

  772. 

  773.             valueStr = strLimDigits(value) + unit

  774.             valueLen = len(valueStr)

  775.             if valueLen == 0:

  776.                 print("Zero length string from " + str(self.fRealValue) + " value.")

  777.                 return

  778. 

  779.         autoFontsize  = int(self.getTweak('Auto7segSize', 0))       # Full auto

  780.         autoFontwidth = int(self.getTweak('Auto7segWidth', 1))      # Width only

  781. 

  782.         skew = -0.2

  783.         substrate = 1

  784.         dY = 3                      # Work in progress here. NOTE

  785.         fntSize = 0.9

  786.         fntAspect = 0.5

  787.         bgLuma = 0.05

  788.         R = 10  # Replace to W

  789.         width = 4

  790.         lineWidth = 2.0

  791. 

  792.         if self.fCustomPaintMode == 0:     # default / internal

  793.             fntSize = 0.75

  794.             Y = Y - 2

  795. 

  796.         elif self.fCustomPaintMode == 16:  # calf

  797.             autoFontsize = 1

  798.             skew = 0

  799.             dY = 4

  800.             bgLuma = 0.1

  801.             R = 12

  802. 

  803.         elif self.fCustomPaintMode == 32:  # openav

  804.             autoFontsize = 1

  805.             substrate = 0

  806.             R = 13

  807.             lineWidth = 3.0

  808. 

  809.         elif self.fCustomPaintMode == 48:  # zynfx

  810.             fntSize = 0.99

  811.             Y = Y - 2

  812.             dY = 4

  813.             bgLuma = 0.12

  814.             R = 12

  815. 

  816.         elif self.fCustomPaintMode == 64:  # tube

  817.             autoFontsize = 1

  818.             R = 13

  819.             lineWidth = 3.0

  820. 

  821.         else:

  822.             print("Unknown paint mode "+ str(self.fCustomPaintMode) + " display.")

  823.             return

  824. 

  825.         if not self.fIsVuOutput:

  826.             if autoFontwidth and (valueLen < 4):

  827.                 if autoFontsize:

  828.                     fntSize = fntSize * 4/3

  829.                 fntAspect = 1.0 - (valueLen-1) * 0.2

  830. 

  831.             lineWidth = fntSize + 0.5                      # Work in progress here. NOTE

  832. 

  833.         # substrate

  834.         if substrate:

  835.             substratePen = QPen(QColor.fromHslF(0, 0, 0.4+E, 1), 0.5)

  836.             if (self.fCustomPaintMode == 64): # tube

  837.                 if not self.fIsVuOutput:

  838.                     self.grayGradPen(painter, X, Y, 135, -1)

  839.                     self.grayGradBrush(painter, X-10, -80, 200, -2, {0.2, 50.2, 51.00, 100.00})

  840.                     painter.drawRoundedRect(squareBorder(-W*0.4, W*0.3), 3, 3)

  841. 

  842.             else:

  843.                 if self.fCustomPaintMode == 16:  # calf

  844.                     if self.fIsVuOutput:

  845.                         dY = 9

  846.                 painter.setPen(substratePen)

  847.                 painter.setBrush(QColor(QColor.fromHslF(0, 0, bgLuma, 1)))

  848.                 painter.drawRoundedRect(squareBorder(-dY, dY), 3, 3)

  849. 

  850. 

  851.         color = QColor.fromHslF(hue, S, L, 1)

  852.         painter.setPen(QPen(color, lineWidth, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))

  853.         if not self.fIsVuOutput:

  854.             plotStr(self, painter, X, Y, valueStr, fntSize, fntAspect, skew);

  855.         else:

  856.             if self.fCustomPaintMode == 16:  # calf        # Work in progress here. NOTE

  857.                 for i in range(0, 10+1):

  858.                     if normValue > ((i+0.5)/11):

  859.                         painter.drawLine(QPointF(X-15+i*3, Y-R/2), QPointF(X-15+i*3, Y+R/2))

  860.             elif self.fCustomPaintMode == 64:  # tube        # Work in progress here. NOTE

  861.                 # Draw Cat eye.

  862.                 chamfer = 1.5 # It is best when 1.5 at normal zoom, and 1.0 for >2x HiDpi

  863. 

  864.                 # base

  865.                 self.grayGradPen(painter, X, Y, -45, -1, width=chamfer)

  866.                 self.grayGradBrush(painter, X-10, -20, 83, -2, {0.2, 50.2, 51.00, 100.00})

  867.                 painter.drawEllipse(squareBorder(-W*0.2))

  868. 

  869.                 # green sectors

  870.                 rays = 4 # There are 4- or 8-rays (2 or 4 notches) tubes

  871.                 gradient = QConicalGradient(X, Y, 0)

  872.                 for i in range(rays):

  873.                     sign = 1 - (i % 2) * 2

  874.                     v = min(normValue, 1) * 1.2 + 0.05  # For output, it can be > max.

  875.                     a = (i % 2) + v * sign

  876.                     b = a + 0.02 * sign

  877.                     if v > 0.99 :

  878.                         # did you notice overlapping sectors?

  879.                         gradient.setColorAt((i+a)/rays, color)

  880.                         gradient.setColorAt((i+b)/rays, color.darker(130))

  881.                     else:

  882.                         b = max(-1, min(1, b))

  883.                         gradient.setColorAt((i+a)/rays, color.darker(130))

  884.                         gradient.setColorAt((i+b)/rays, color.darker(300))

  885. 

  886.                 self.grayGradPen(painter, X, Y, 0, -1, width=chamfer)

  887.                 painter.setBrush(gradient)

  888.                 painter.drawEllipse(squareBorder(-W*0.4))

  889. 

  890.                 # cap is black itself, but looks dark green on working tube.

  891.                 self.drawMark(painter, X, Y, 0, 0, 0, W/4, color.darker(800))

  892. 

  893.             else:

  894.                 # VU scale points

  895.                 for i in range(0, 5+1):

  896.                     angle = ((0.5-i/5) * 110 + 90)

  897.                     self.drawMark(painter, X, Y + R*0.6, R*1.3, R*1.5, angle, lineWidth-0.5, color.darker(150))

  898. 

  899.                 # VU pointer

  900.                 angle = ((0.5-normValue) * 110 + 90)

  901.                 self.drawMark(painter, X, Y + R*0.6, 0, R*1.3, angle, lineWidth, color)

  902. 

  903.                 # Draw "settling screw" of VU meter        # Work in progress here. NOTE

  904.                 if substrate:

  905.                     painter.setPen(substratePen)

  906.                     painter.drawEllipse(QRectF(X-width, Y+R*0.6-width, width*2, width*2))

  907. 

  908. # ---------------------------------------------------------------------------------------------------------------------