falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 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.
966 Commits
16 Branches
152MB
Tree: 46a13d7554
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '46a13d7554'
${ noResults }
Carla/source/widgets/pixmapdial.py

300 lines
11KB
Raw Blame History 

  1. #!/usr/bin/env python3

  2. # -*- coding: utf-8 -*-

  3. 

  4. # Pixmap Dial, a custom Qt4 widget

  5. # Copyright (C) 2011-2013 Filipe Coelho <falktx@falktx.com>

  6. #

  7. # This program is free software; you can redistribute it and/or

  8. # modify it under the terms of the GNU General Public License as

  9. # published by the Free Software Foundation; either version 2 of

  10. # the License, or any later version.

  11. #

  12. # This program is distributed in the hope that it will be useful,

  13. # but WITHOUT ANY WARRANTY; without even the implied warranty of

  14. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  15. # GNU General Public License for more details.

  16. #

  17. # For a full copy of the GNU General Public License see the doc/GPL.txt file.

  18. 

  19. # ------------------------------------------------------------------------------------------------------------

  20. # Imports (Global)

  21. 

  22. from math import floor

  23. from PyQt5.QtCore import Qt, QPointF, QRectF, QTimer, QSize

  24. from PyQt5.QtGui import QColor, QConicalGradient, QFont, QFontMetrics

  25. from PyQt5.QtGui import QLinearGradient, QPainter, QPainterPath, QPen, QPixmap

  26. from PyQt5.QtWidgets import QDial

  27. 

  28. # ------------------------------------------------------------------------------------------------------------

  29. # Widget Class

  30. 

  31. class PixmapDial(QDial):

  32.     # enum CustomPaint

  33.     CUSTOM_PAINT_NULL      = 0

  34.     CUSTOM_PAINT_CARLA_WET = 1

  35.     CUSTOM_PAINT_CARLA_VOL = 2

  36.     CUSTOM_PAINT_CARLA_L   = 3

  37.     CUSTOM_PAINT_CARLA_R   = 4

  38. 

  39.     # enum Orientation

  40.     HORIZONTAL = 0

  41.     VERTICAL   = 1

  42. 

  43.     HOVER_MIN = 0

  44.     HOVER_MAX = 9

  45. 

  46.     def __init__(self, parent):

  47.         QDial.__init__(self, parent)

  48. 

  49.         self.fPixmap      = QPixmap(":/bitmaps/dial_01d.png")

  50.         self.fPixmapNum   = "01"

  51.         self.fCustomPaint = self.CUSTOM_PAINT_NULL

  52. 

  53.         self.fIsHovered = False

  54.         self.fHoverStep = self.HOVER_MIN

  55. 

  56.         if self.fPixmap.width() > self.fPixmap.height():

  57.             self.fOrientation = self.HORIZONTAL

  58.         else:

  59.             self.fOrientation = self.VERTICAL

  60. 

  61.         self.fLabel     = ""

  62.         self.fLabelPos  = QPointF(0.0, 0.0)

  63.         self.fLabelFont = QFont()

  64.         self.fLabelFont.setPointSize(6)

  65.         self.fLabelWidth  = 0

  66.         self.fLabelHeight = 0

  67.         self.fLabelGradient = QLinearGradient(0, 0, 0, 1)

  68. 

  69.         if self.palette().window().color().lightness() > 100:

  70.             # Light background

  71.             c = self.palette().dark().color()

  72.             self.fColor1 = c

  73.             self.fColor2 = QColor(c.red(), c.green(), c.blue(), 0)

  74.             self.fColorT = [self.palette().buttonText().color(), self.palette().mid().color()]

  75.         else:

  76.             # Dark background

  77.             self.fColor1 = QColor(0, 0, 0, 255)

  78.             self.fColor2 = QColor(0, 0, 0, 0)

  79.             self.fColorT = [Qt.white, Qt.darkGray]

  80. 

  81.         self.updateSizes()

  82. 

  83.     def getSize(self):

  84.         return self.fSize

  85. 

  86.     def setCustomPaint(self, paint):

  87.         self.fCustomPaint = paint

  88.         self.fLabelPos.setY(self.fSize + self.fLabelHeight/2)

  89.         self.update()

  90. 

  91.     def setEnabled(self, enabled):

  92.         if self.isEnabled() != enabled:

  93.             self.fPixmap.load(":/bitmaps/dial_%s%s.png" % (self.fPixmapNum, "" if enabled else "d"))

  94.             self.updateSizes()

  95.             self.update()

  96.         QDial.setEnabled(self, enabled)

  97. 

  98.     def setLabel(self, label):

  99.         self.fLabel = label

  100. 

  101.         self.fLabelWidth  = QFontMetrics(self.fLabelFont).width(label)

  102.         self.fLabelHeight = QFontMetrics(self.fLabelFont).height()

  103. 

  104.         self.fLabelPos.setX(float(self.fSize)/2.0 - float(self.fLabelWidth)/2.0)

  105.         self.fLabelPos.setY(self.fSize + self.fLabelHeight)

  106. 

  107.         self.fLabelGradient.setColorAt(0.0, self.fColor1)

  108.         self.fLabelGradient.setColorAt(0.6, self.fColor1)

  109.         self.fLabelGradient.setColorAt(1.0, self.fColor2)

  110. 

  111.         self.fLabelGradient.setStart(0, float(self.fSize)/2.0)

  112.         self.fLabelGradient.setFinalStop(0, self.fSize + self.fLabelHeight + 5)

  113. 

  114.         self.fLabelGradientRect = QRectF(float(self.fSize)/8.0, float(self.fSize)/2.0, float(self.fSize*6)/8.0, self.fSize+self.fLabelHeight+5)

  115.         self.update()

  116. 

  117.     def setPixmap(self, pixmapId):

  118.         self.fPixmapNum = "%02i" % pixmapId

  119.         self.fPixmap.load(":/bitmaps/dial_%s%s.png" % (self.fPixmapNum, "" if self.isEnabled() else "d"))

  120. 

  121.         if self.fPixmap.width() > self.fPixmap.height():

  122.             self.fOrientation = self.HORIZONTAL

  123.         else:

  124.             self.fOrientation = self.VERTICAL

  125. 

  126.         self.updateSizes()

  127.         self.update()

  128. 

  129.     def minimumSizeHint(self):

  130.         return QSize(self.fSize, self.fSize)

  131. 

  132.     def sizeHint(self):

  133.         return QSize(self.fSize, self.fSize)

  134. 

  135.     def updateSizes(self):

  136.         self.fWidth  = self.fPixmap.width()

  137.         self.fHeight = self.fPixmap.height()

  138. 

  139.         if self.fWidth < 1:

  140.             self.fWidth = 1

  141. 

  142.         if self.fHeight < 1:

  143.             self.fHeight = 1

  144. 

  145.         if self.fOrientation == self.HORIZONTAL:

  146.             self.fSize  = self.fHeight

  147.             self.fCount = self.fWidth / self.fHeight

  148.         else:

  149.             self.fSize  = self.fWidth

  150.             self.fCount = self.fHeight / self.fWidth

  151. 

  152.         self.setMinimumSize(self.fSize, self.fSize + self.fLabelHeight + 5)

  153.         self.setMaximumSize(self.fSize, self.fSize + self.fLabelHeight + 5)

  154. 

  155.     def enterEvent(self, event):

  156.         self.fIsHovered = True

  157.         if self.fHoverStep == self.HOVER_MIN:

  158.             self.fHoverStep = self.HOVER_MIN + 1

  159.         QDial.enterEvent(self, event)

  160. 

  161.     def leaveEvent(self, event):

  162.         self.fIsHovered = False

  163.         if self.fHoverStep == self.HOVER_MAX:

  164.             self.fHoverStep = self.HOVER_MAX - 1

  165.         QDial.leaveEvent(self, event)

  166. 

  167.     def paintEvent(self, event):

  168.         painter = QPainter(self)

  169.         event.accept()

  170. 

  171.         painter.save()

  172.         painter.setRenderHint(QPainter.Antialiasing, True)

  173. 

  174.         if self.fLabel:

  175.             if self.fCustomPaint == self.CUSTOM_PAINT_NULL:

  176.                 painter.setPen(self.fColor2)

  177.                 painter.setBrush(self.fLabelGradient)

  178.                 painter.drawRect(self.fLabelGradientRect)

  179. 

  180.             painter.setFont(self.fLabelFont)

  181.             painter.setPen(self.fColorT[0 if self.isEnabled() else 1])

  182.             painter.drawText(self.fLabelPos, self.fLabel)

  183. 

  184.         if self.isEnabled():

  185.             current = float(self.value() - self.minimum())

  186.             divider = float(self.maximum() - self.minimum())

  187. 

  188.             if divider == 0.0:

  189.                 return

  190. 

  191.             value  = current / divider

  192.             target = QRectF(0.0, 0.0, self.fSize, self.fSize)

  193. 

  194.             per = int((self.fCount - 1) * value)

  195. 

  196.             if self.fOrientation == self.HORIZONTAL:

  197.                 xpos = self.fSize * per

  198.                 ypos = 0.0

  199.             else:

  200.                 xpos = 0.0

  201.                 ypos = self.fSize * per

  202. 

  203.             source = QRectF(xpos, ypos, self.fSize, self.fSize)

  204.             painter.drawPixmap(target, self.fPixmap, source)

  205. 

  206.             # Custom knobs (Dry/Wet and Volume)

  207.             if self.fCustomPaint in (self.CUSTOM_PAINT_CARLA_WET, self.CUSTOM_PAINT_CARLA_VOL):

  208.                 # knob color

  209.                 colorGreen = QColor(0x5D, 0xE7, 0x3D, 191 + self.fHoverStep*7)

  210.                 colorBlue  = QColor(0x3E, 0xB8, 0xBE, 191 + self.fHoverStep*7)

  211. 

  212.                 # draw small circle

  213.                 ballRect = QRectF(8.0, 8.0, 15.0, 15.0)

  214.                 ballPath = QPainterPath()

  215.                 ballPath.addEllipse(ballRect)

  216.                 #painter.drawRect(ballRect)

  217.                 tmpValue  = (0.375 + 0.75*value)

  218.                 ballValue = tmpValue - floor(tmpValue)

  219.                 ballPoint = ballPath.pointAtPercent(ballValue)

  220. 

  221.                 # draw arc

  222.                 startAngle = 216*16

  223.                 spanAngle  = -252*16*value

  224. 

  225.                 if self.fCustomPaint == self.CUSTOM_PAINT_CARLA_WET:

  226.                     painter.setBrush(colorBlue)

  227.                     painter.setPen(QPen(colorBlue, 0))

  228.                     painter.drawEllipse(QRectF(ballPoint.x(), ballPoint.y(), 2.2, 2.2))

  229. 

  230.                     gradient = QConicalGradient(15.5, 15.5, -45)

  231.                     gradient.setColorAt(0.0,   colorBlue)

  232.                     gradient.setColorAt(0.125, colorBlue)

  233.                     gradient.setColorAt(0.625, colorGreen)

  234.                     gradient.setColorAt(0.75,  colorGreen)

  235.                     gradient.setColorAt(0.76,  colorGreen)

  236.                     gradient.setColorAt(1.0,   colorGreen)

  237.                     painter.setBrush(gradient)

  238.                     painter.setPen(QPen(gradient, 3))

  239. 

  240.                 else:

  241.                     painter.setBrush(colorBlue)

  242.                     painter.setPen(QPen(colorBlue, 0))

  243.                     painter.drawEllipse(QRectF(ballPoint.x(), ballPoint.y(), 2.2, 2.2))

  244. 

  245.                     painter.setBrush(colorBlue)

  246.                     painter.setPen(QPen(colorBlue, 3))

  247. 

  248.                 painter.drawArc(4.0, 4.0, 26.0, 26.0, startAngle, spanAngle)

  249. 

  250.             # Custom knobs (L and R)

  251.             elif self.fCustomPaint in (self.CUSTOM_PAINT_CARLA_L, self.CUSTOM_PAINT_CARLA_R):

  252.                 # knob color

  253.                 color = QColor(0xAD + self.fHoverStep*5, 0xD5 + self.fHoverStep*4, 0x4B + self.fHoverStep*5)

  254. 

  255.                 # draw small circle

  256.                 ballRect = QRectF(7.0, 8.0, 11.0, 12.0)

  257.                 ballPath = QPainterPath()

  258.                 ballPath.addEllipse(ballRect)

  259.                 #painter.drawRect(ballRect)

  260.                 tmpValue  = (0.375 + 0.75*value)

  261.                 ballValue = tmpValue - floor(tmpValue)

  262.                 ballPoint = ballPath.pointAtPercent(ballValue)

  263. 

  264.                 painter.setBrush(color)

  265.                 painter.setPen(QPen(color, 0))

  266.                 painter.drawEllipse(QRectF(ballPoint.x(), ballPoint.y(), 2.0, 2.0))

  267. 

  268.                 # draw arc

  269.                 if self.fCustomPaint == self.CUSTOM_PAINT_CARLA_L:

  270.                     startAngle = 216*16

  271.                     spanAngle  = -252.0*16*value

  272.                 elif self.fCustomPaint == self.CUSTOM_PAINT_CARLA_R:

  273.                     startAngle = 324.0*16

  274.                     spanAngle  = 252.0*16*(1.0-value)

  275.                 else:

  276.                     return

  277. 

  278.                 painter.setPen(QPen(color, 2))

  279.                 painter.drawArc(3.5, 4.5, 22.0, 22.0, startAngle, spanAngle)

  280. 

  281.             # Custom knobs

  282.             else:

  283.                 painter.restore()

  284.                 return

  285. 

  286.             if self.HOVER_MIN < self.fHoverStep < self.HOVER_MAX:

  287.                 self.fHoverStep += 1 if self.fIsHovered else -1

  288.                 QTimer.singleShot(20, self.update)

  289. 

  290.         else: # isEnabled()

  291.             target = QRectF(0.0, 0.0, self.fSize, self.fSize)

  292.             painter.drawPixmap(target, self.fPixmap, target)

  293. 

  294.         painter.restore()

  295. 

  296.     def resizeEvent(self, event):

  297.         self.updateSizes()

  298.         QDial.resizeEvent(self, event)