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.
7047 Commits
17 Branches
992MB
Tree: 3d580b9ed9
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '3d580b9ed9'
${ noResults }
Carla/source/frontend/widgets/scalabledial.py

908 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_MAX )

  32. 

  33. # ---------------------------------------------------------------------------------------------------------------------

  34. # Widget Class

  35. 

  36. class ScalableDial(CommonDial):

  37.     def __init__(self, parent, index,

  38.                                precision,

  39.                                default,

  40.                                minimum,

  41.                                maximum,

  42.                                label,

  43.                                paintMode,

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

  45.                                unit         = "%",       # Measurement Unit

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

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

  48.                                tweaks       = {},

  49.                                isInteger    = 0,         # Input is Integer

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

  51.                                isOutput     = 0,

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

  53.                                isVisible    = 1 ):

  54. 

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

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

  57. 

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

  59.     def updateSizes(self):

  60.         knownModes = [

  61.             # default

  62.             self.CUSTOM_PAINT_MODE_NULL          , #  0

  63.             self.CUSTOM_PAINT_MODE_CARLA_WET     , #  1

  64.             self.CUSTOM_PAINT_MODE_CARLA_VOL     , #  2

  65.             self.CUSTOM_PAINT_MODE_CARLA_L       , #  3

  66.             self.CUSTOM_PAINT_MODE_CARLA_R       , #  4

  67.             self.CUSTOM_PAINT_MODE_CARLA_PAN     , #  5

  68.             self.CUSTOM_PAINT_MODE_CARLA_FORTH   , #  6

  69.             self.CUSTOM_PAINT_MODE_CARLA_WET_MINI, #  9

  70.             self.CUSTOM_PAINT_MODE_CARLA_VOL_MINI, # 10

  71.             # calf

  72.             16,

  73.             # openav

  74.             32, 33, 34, 37, 38,

  75.             # zynfx

  76.             48, 49, 50, 53, 54,

  77.             # tube

  78.             64, 65, 66, 69, 70,

  79.         ]

  80. 

  81.         index = -1

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

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

  84.                 index = i

  85.                 break

  86. 

  87.         if (index == -1):

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

  89.             return

  90. 

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

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

  93. 

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

  95.             # default   Aqua

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

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

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

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

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

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

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

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

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

  105.             # calf      Blue

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

  107.             # openav   Orange

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

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

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

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

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

  113.             # zynfx     Teal

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

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

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

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

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

  119.             # tube      VFD

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

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

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

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

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

  125.         ] [index]

  126. 

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

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

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

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

  131.         self.fWidth = self.fHeight = width

  132. 

  133.         # Angle span (travel)

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

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

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

  137. 

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

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

  140. 

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

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

  143. 

  144.         # Point, line or other accent on knob

  145.         self.fPointSize = point

  146. 

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

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

  149.             self.fHueA = hueA

  150.             self.fHueB = hueB

  151.         # default and openav can be re-colored

  152.         elif self.colorFollow:

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

  154.         else:

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

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

  157. 

  158. 

  159.         metrics = QFontMetrics(self.fLabelFont)

  160. 

  161.         if not self.fLabel:

  162.             self.fLabelWidth = 0

  163.         else:

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

  165. 

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

  167. 

  168.         self.fLabelHeight = metrics.height()

  169. 

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

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

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

  173. 

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

  175.                 extraWidth = max(extraWidth, extraWidthAuto)

  176. 

  177.             extraWidth = min(extraWidth, extraWidthLimit)

  178. 

  179.             self.fWidth = self.fWidth + extraWidth

  180. 

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

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

  183. 

  184.         if not self.fLabel:

  185.             self.fLabelHeight = 0

  186.             # self.fLabelWidth  = 0

  187.             return

  188. 

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

  190. 

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

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

  193. 

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

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

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

  197. 

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

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

  200. 

  201.     def setImage(self, imageId):

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

  203.         return

  204. 

  205.     def minimumSizeHint(self):

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

  207. 

  208.     def sizeHint(self):

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

  210. 

  211.     # def changeEvent(self, event):

  212.     #     CommonDial.changeEvent(self, event)

  213.     #

  214.     #     # Force svg update if enabled state changes

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

  216.     #         self.slot_updateImage()

  217. 

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

  219.         A = angle * pi/180

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

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

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

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

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

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

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

  227.         else:               # ball

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

  229. 

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

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

  232. 

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

  234.         if b == -1:

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

  236.         elif b == -2:

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

  238.         else:

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

  240. 

  241.         for i in gradPairs:

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

  243. 

  244.         return grad

  245. 

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

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

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

  249. 

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

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

  252. 

  253. 

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

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

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

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

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

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

  260.     # R: knob nib (cap) radius

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

  262.         R = self.fRadius

  263.         barWidth = self.fPointSize

  264.         angleSpan = self.fTravel

  265. 

  266.         hueA = self.fHueA

  267.         hueB = self.fHueB

  268. 

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

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

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

  272. 

  273.         skin = self.skin

  274. 

  275.         def ang(value):

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

  277. 

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

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

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

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

  282.             if ticks:

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

  284. 

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

  286. 

  287.         def squareBorder(w):

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

  289. 

  290.         def gray(luma):

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

  292. 

  293. 

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

  295.         if self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_CARLA_L:

  296.             refValue = 0

  297.         elif self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_CARLA_R:

  298.             refValue = 1

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

  300.             refValue = 0.5

  301.         else:

  302.             refValue = 0

  303. 

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

  305. 

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

  307. 

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

  309.             if knobMuted:

  310.                 if self.fIndex == PARAMETER_DRYWET:

  311.                     self.pushLabel("Thru")

  312.                 elif self.fIndex == PARAMETER_VOLUME:

  313.                     self.pushLabel("Mute")

  314.                 elif self.fIndex == PARAMETER_PANNING:

  315.                     self.pushLabel("Center")

  316.                 else:

  317.                     self.pushLabel("Midway")

  318.             else:

  319.                 self.popLabel()

  320. 

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

  322.             # if not knobMuted:

  323.             if not (knobMuted and haveLed):

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

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

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

  327. 

  328.                 # light arc: gray bar

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

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

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

  332. 

  333.             # cap

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

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

  336.             painter.drawEllipse(squareBorder(1))

  337. 

  338.         elif skin == 1: # calf

  339.             # outer chamfer & leds substrate

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

  341.             painter.setBrush(color0a)

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

  343. 

  344.             # machined shiny cap with chamfer

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

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

  347.             painter.drawEllipse(squareBorder(1))

  348. 

  349.         elif skin == 2: # openav

  350.             # light arc substrate

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

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

  353. 

  354.         elif skin == 3: # zynfx

  355.             # light arc substrate

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

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

  358. 

  359.             # cap

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

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

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

  363. 

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

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

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

  367.             # base

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

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

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

  371.                 painter.drawEllipse(squareBorder(1))

  372.             else:               # round knob: larger base

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

  374. 

  375.             polygon = QPolygonF()

  376.             # "chickenhead" pointer

  377.             if self.fIsInteger:

  378.                 for i in range(17):

  379.                     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

  380.                     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

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

  382.             # 8-teeth round knob outline

  383.             else:

  384.                 for i in range(64):

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

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

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

  388. 

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

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

  391.             painter.drawPolygon(polygon)

  392. 

  393.             # machined shiny penny with chamfer

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

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

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

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

  398.             else:               # round knob: large one

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

  400. 

  401.             # Outer scale marks

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

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

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

  405. 

  406.         # if knobMuted:

  407.         if (knobMuted and haveLed):

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

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

  410.             return

  411. 

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

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

  414. 

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

  416.             cap=Qt.FlatCap

  417. 

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

  419.                 ticks = 0

  420.                 gradient.setColorAt(0.75, color0)

  421.                 gradient.setColorAt(0.25, color1)

  422.                 if skin == 3: # zynfx

  423.                     # light arc partial (angled) black substrate

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

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

  426.                 elif skin == 2: # openav

  427.                     cap=Qt.RoundCap

  428.             else: # calf

  429.                 ticks = 36

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

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

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

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

  434. 

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

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

  437. 

  438.         # do not draw marks on disabled items

  439.         if not enabled:

  440.             return

  441. 

  442.         A = ang(normValue)

  443. 

  444.         match skin:

  445.             case 0: # ball

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

  447.             case 1: # line for calf

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

  449.             case 2: # line for openav

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

  451.             case 3: # line for zynfx

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

  453.             case 4: # ball

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

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

  456. 

  457. 

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

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

  460.         W = self.fRadius

  461.         w = self.fPointSize

  462. 

  463.         hue = self.fHueA

  464. 

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

  466. 

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

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

  469. 

  470.         def gray(luma):

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

  472. 

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

  474. 

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

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

  477. 

  478.         if skin == 0: # internal

  479.             if not centerLed:

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

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

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

  483. 

  484.                 # light bar: gray bar

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

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

  487. 

  488.             # cap

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

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

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

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

  493. 

  494.         elif skin == 1: # calf

  495.             # outer chamfer & leds substrate

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

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

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

  499. 

  500.             # machined shiny cap with chamfer

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

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

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

  504. 

  505.         elif skin == 2: # openav

  506.             # light substrate

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

  508.             painter.setPen(pen)

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

  510. 

  511.         elif skin == 3: # zynfx

  512.             if not centerLed:

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

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

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

  516. 

  517.             # button

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

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

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

  521. 

  522.         elif skin == 4: # tube

  523.             # bakelite cap

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

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

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

  527. 

  528.             # neon lamp

  529.             if (normValue > 0):

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

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

  532.                     if coloredNeon:

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

  534.                     else:

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

  536. 

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

  538.                 painter.setBrush(grad)

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

  540. 

  541.             # glass over neon lamp

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

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

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

  545. 

  546.         # draw active lights

  547.         if skin == 0:  # internal

  548.             if not centerLed:

  549.                 if (normValue > 0):

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

  551.                     if (normValue < 1):

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

  553.                     else:

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

  555.             else:

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

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

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

  559. 

  560.         elif skin == 1: # calf

  561.             if (normValue > 0):

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

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

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

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

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

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

  568. 

  569.         elif skin == 2:  # openav

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

  571.             if (normValue > 0):

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

  573.             else:

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

  575. 

  576.         elif skin == 3:  # zynfx

  577.             if not centerLed:

  578.                 if (normValue > 0):

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

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

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

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

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

  584.             else:

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

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

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

  588. 

  589.         # do not draw marks on disabled items

  590.         if not enabled:

  591.             return

  592. 

  593.         match skin:

  594.             case 0: # internal: ball at center

  595.                 if not centerLed:

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

  597.             # case 3: # openav

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

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

  600.             case 3: # zynfx: ball at center

  601.                 if not centerLed:

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

  603. 

  604. 

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

  606.     # NOTE Work in progress.

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

  608. 

  609.         # X, Y: Center of label.

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

  611. 

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

  613.             # Shape to Speed balance: Speed

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

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

  616.                  "KYNJVJVRNRNZVZ",              # 2        NZ RZ VZ

  617.                  "KYNJVJVZNZ RVRNR",            # 3          P]

  618.                  "KYNJNRVR RVJVZ",              # 4

  619.                  "KYVJNJNRVRVZNZ",              # 5

  620.                  "KYVJNJNZVZVRNR",              # 6

  621.                  "KYNJVJVZ",                    # 7

  622.                  "KYNJNZVZVJNJ RNRVR",          # 8

  623.                  "KYNZVZVJNJNRVR",              # 9

  624.                  "KYNRVR",                      # -

  625.                  "OTRZP]",                      # .

  626.                  "KYNNNX RVPNTVX",              # k

  627.                  "KYNXNLRRVLVX"     ]           # M

  628. 

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

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

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

  632.                 if justGetWidth:

  633.                     return X + rm - lm

  634. 

  635.                 points = []

  636.                 X = X - lm

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

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

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

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

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

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

  643.                         painter.drawPolyline(points)

  644.                         points = []

  645.                     else:

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

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

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

  649. 

  650.                 painter.drawPolyline(points)

  651.                 X = X + rm

  652.                 return X

  653. 

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

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

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

  657.                     if digit < 0:

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

  659.                     else:

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

  661.                 return X

  662. 

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

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

  665.             return

  666. 

  667.         def strLimDigits(x):

  668.             s = str(x)

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

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

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

  672. 

  673.         def plotNixie(n):

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

  675. 

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

  677.             # Arcs are perfectly matched with original tube.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  694. 

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

  696.                 if a0 == a1 == 0:

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

  698.                 else:

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

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

  701. 

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

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

  704. 

  705.         W = Y-1                             # "radius"

  706.         value = self.fRealValue

  707.         hue = self.fHueA

  708. 

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

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

  711.             # Neon lamp

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

  713.                 # bakelite lamp holder

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

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

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

  717. 

  718.                 # neon lamp

  719.                 if (normValue > 0):

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

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

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

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

  724.                     painter.setBrush(grad)

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

  726. 

  727.                 # glass over neon lamp

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

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

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

  731.                 return

  732. 

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

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

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

  736.             return

  737. 

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

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

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

  741.             Y = Y - 2

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

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

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

  745. 

  746.             if (value < 10):

  747.                 plotNixie(int(value % 10))

  748.             else:

  749.                 if (value == 11):

  750.                     X = X + 8

  751.                     plotNixie(1)

  752.                 else:

  753.                     X = X + 4

  754.                     plotNixie(int(value % 10))

  755.                 X = X - 16

  756.                 plotNixie(1)

  757.             return

  758. 

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

  760.         if not self.fIsVuOutput:

  761.             unit = ""

  762.             if abs(value) >= 10000.0:

  763.                 value = value / 1000.0

  764.                 unit = "k"

  765.             if abs(value) >= 10000.0:

  766.                 value = value / 1000.0

  767.                 unit = "M"

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

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

  770.                 value = int(value)

  771. 

  772.             valueStr = strLimDigits(value) + unit

  773.             valueLen = len(valueStr)

  774.             if valueLen == 0:

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

  776.                 return

  777. 

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

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

  780. 

  781.         skew = -0.2

  782.         substrate = 1

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

  784.         fntSize = 0.9

  785.         fntAspect = 0.5

  786.         bgLuma = 0.05

  787.         R = 10  # Replace to W

  788.         width = 4

  789.         lineWidth = 2.0

  790. 

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

  792.             fntSize = 0.75

  793.             Y = Y - 2

  794. 

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

  796.             autoFontsize = 1

  797.             skew = 0

  798.             dY = 4

  799.             bgLuma = 0.1

  800.             R = 12

  801. 

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

  803.             autoFontsize = 1

  804.             substrate = 0

  805.             R = 13

  806.             lineWidth = 3.0

  807. 

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

  809.             fntSize = 0.99

  810.             Y = Y - 2

  811.             dY = 4

  812.             bgLuma = 0.12

  813.             R = 12

  814. 

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

  816.             autoFontsize = 1

  817.             R = 13

  818.             lineWidth = 3.0

  819. 

  820.         else:

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

  822.             return

  823. 

  824.         if not self.fIsVuOutput:

  825.             if autoFontwidth and (valueLen < 4):

  826.                 if autoFontsize:

  827.                     fntSize = fntSize * 4/3

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

  829. 

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

  831. 

  832.         # substrate

  833.         if substrate:

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

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

  836.                 if not self.fIsVuOutput:

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

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

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

  840. 

  841.             else:

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

  843.                     if self.fIsVuOutput:

  844.                         dY = 9

  845.                 painter.setPen(substratePen)

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

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

  848. 

  849. 

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

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

  852.         if not self.fIsVuOutput:

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

  854.         else:

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

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

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

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

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

  860.                 # Draw Cat eye.

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

  862. 

  863.                 # base

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

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

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

  867. 

  868.                 # green sectors

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

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

  871.                 for i in range(rays):

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

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

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

  875.                     b = a + 0.02 * sign

  876.                     if v > 0.99 :

  877.                         # did you notice overlapping sectors?

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

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

  880.                     else:

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

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

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

  884. 

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

  886.                 painter.setBrush(gradient)

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

  888. 

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

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

  891. 

  892.             else:

  893.                 # VU scale points

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

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

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

  897. 

  898.                 # VU pointer

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

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

  901. 

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

  903.                 if substrate:

  904.                     painter.setPen(substratePen)

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

  906. 

  907. # ---------------------------------------------------------------------------------------------------------------------