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.
852 Commits
17 Branches
116MB
Tree: 8a5d2b8bb0
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '8a5d2b8bb0'
${ noResults }
Carla/source/modules/widgets/pixmapdial.py

296 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. # TODO - SLOTS

  23. 

  24. from math import floor

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

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

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

  28. from PyQt5.QtWidgets import QDial

  29. 

  30. # ------------------------------------------------------------------------------------------------------------

  31. # Widget Class

  32. 

  33. class PixmapDial(QDial):

  34.     # enum CustomPaint

  35.     CUSTOM_PAINT_NULL      = 0

  36.     CUSTOM_PAINT_CARLA_WET = 1

  37.     CUSTOM_PAINT_CARLA_VOL = 2

  38.     CUSTOM_PAINT_CARLA_L   = 3

  39.     CUSTOM_PAINT_CARLA_R   = 4

  40. 

  41.     # enum Orientation

  42.     HORIZONTAL = 0

  43.     VERTICAL   = 1

  44. 

  45.     HOVER_MIN = 0

  46.     HOVER_MAX = 9

  47. 

  48.     def __init__(self, parent):

  49.         QDial.__init__(self, parent)

  50. 

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

  52.         self.fPixmapNum   = "01"

  53.         self.fCustomPaint = self.CUSTOM_PAINT_NULL

  54. 

  55.         self.fHovered   = False

  56.         self.fHoverStep = self.HOVER_MIN

  57. 

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

  59.             self.fOrientation = self.HORIZONTAL

  60.         else:

  61.             self.fOrientation = self.VERTICAL

  62. 

  63.         self.fLabel     = ""

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

  65.         self.fLabelFont = QFont()

  66.         self.fLabelFont.setPointSize(6)

  67.         self.fLabelWidth  = 0

  68.         self.fLabelHeight = 0

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

  70. 

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

  72.             # Light background

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

  74.             self.fColor1 = c

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

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

  77.         else:

  78.             # Dark background

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

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

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

  82. 

  83.         self.updateSizes()

  84. 

  85.     def getSize(self):

  86.         return self.fSize

  87. 

  88.     def setCustomPaint(self, paint):

  89.         self.fCustomPaint = paint

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

  91.         self.update()

  92. 

  93.     def setEnabled(self, enabled):

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

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

  96.             self.updateSizes()

  97.             self.update()

  98.         QDial.setEnabled(self, enabled)

  99. 

  100.     def setLabel(self, label):

  101.         self.fLabel = label

  102. 

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

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

  105. 

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

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

  108. 

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

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

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

  112. 

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

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

  115. 

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

  117.         self.update()

  118. 

  119.     def setPixmap(self, pixmapId):

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

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

  122. 

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

  124.             self.fOrientation = self.HORIZONTAL

  125.         else:

  126.             self.fOrientation = self.VERTICAL

  127. 

  128.         self.updateSizes()

  129.         self.update()

  130. 

  131.     def minimumSizeHint(self):

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

  133. 

  134.     def sizeHint(self):

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

  136. 

  137.     def updateSizes(self):

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

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

  140. 

  141.         if self.fWidth < 1:

  142.             self.fWidth = 1

  143. 

  144.         if self.fHeight < 1:

  145.             self.fHeight = 1

  146. 

  147.         if self.fOrientation == self.HORIZONTAL:

  148.             self.fSize  = self.fHeight

  149.             self.fCount = self.fWidth / self.fHeight

  150.         else:

  151.             self.fSize  = self.fWidth

  152.             self.fCount = self.fHeight / self.fWidth

  153. 

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

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

  156. 

  157.     def enterEvent(self, event):

  158.         self.fHovered = True

  159.         if self.fHoverStep == self.HOVER_MIN:

  160.             self.fHoverStep = self.HOVER_MIN + 1

  161.         QDial.enterEvent(self, event)

  162. 

  163.     def leaveEvent(self, event):

  164.         self.fHovered = False

  165.         if self.fHoverStep == self.HOVER_MAX:

  166.             self.fHoverStep = self.HOVER_MAX - 1

  167.         QDial.leaveEvent(self, event)

  168. 

  169.     def paintEvent(self, event):

  170.         event.accept()

  171. 

  172.         painter = QPainter(self)

  173.         painter.save()

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

  175. 

  176.         if self.fLabel:

  177.             if self.fCustomPaint == self.CUSTOM_PAINT_NULL:

  178.                 painter.setPen(self.fColor2)

  179.                 painter.setBrush(self.fLabelGradient)

  180.                 painter.drawRect(self.fLabelGradientRect)

  181. 

  182.             painter.setFont(self.fLabelFont)

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

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

  185. 

  186.         if self.isEnabled():

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

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

  189. 

  190.             if divider == 0.0:

  191.                 return

  192. 

  193.             value  = current / divider

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

  195. 

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

  197. 

  198.             if self.fOrientation == self.HORIZONTAL:

  199.                 xpos = self.fSize * per

  200.                 ypos = 0.0

  201.             else:

  202.                 xpos = 0.0

  203.                 ypos = self.fSize * per

  204. 

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

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

  207. 

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

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

  210.                 # knob color

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

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

  213. 

  214.                 # draw small circle

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

  216.                 ballPath = QPainterPath()

  217.                 ballPath.addEllipse(ballRect)

  218.                 #painter.drawRect(ballRect)

  219.                 tmpValue  = (0.375 + 0.75*value)

  220.                 ballValue = tmpValue - floor(tmpValue)

  221.                 ballPoint = ballPath.pointAtPercent(ballValue)

  222. 

  223.                 # draw arc

  224.                 startAngle = 216*16

  225.                 spanAngle  = -252*16*value

  226. 

  227.                 if self.fCustomPaint == self.CUSTOM_PAINT_CARLA_WET:

  228.                     painter.setBrush(colorBlue)

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

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

  231. 

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

  233.                     gradient.setColorAt(0.0,   colorBlue)

  234.                     gradient.setColorAt(0.125, colorBlue)

  235.                     gradient.setColorAt(0.625, colorGreen)

  236.                     gradient.setColorAt(0.75,  colorGreen)

  237.                     gradient.setColorAt(0.76,  colorGreen)

  238.                     gradient.setColorAt(1.0,   colorGreen)

  239.                     painter.setBrush(gradient)

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

  241. 

  242.                 else:

  243.                     painter.setBrush(colorBlue)

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

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

  246. 

  247.                     painter.setBrush(colorBlue)

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

  249. 

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

  251. 

  252.             # Custom knobs (L and R)

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

  254.                 # knob color

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

  256. 

  257.                 # draw small circle

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

  259.                 ballPath = QPainterPath()

  260.                 ballPath.addEllipse(ballRect)

  261.                 #painter.drawRect(ballRect)

  262.                 tmpValue  = (0.375 + 0.75*value)

  263.                 ballValue = tmpValue - floor(tmpValue)

  264.                 ballPoint = ballPath.pointAtPercent(ballValue)

  265. 

  266.                 painter.setBrush(color)

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

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

  269. 

  270.                 # draw arc

  271.                 if self.fCustomPaint == self.CUSTOM_PAINT_CARLA_L:

  272.                     startAngle = 216*16

  273.                     spanAngle  = -252.0*16*value

  274.                 elif self.fCustomPaint == self.CUSTOM_PAINT_CARLA_R:

  275.                     startAngle = 324.0*16

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

  277.                 else:

  278.                     return

  279. 

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

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

  282. 

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

  284.                 self.fHoverStep += 1 if self.fHovered else -1

  285.                 QTimer.singleShot(20, self, SLOT("update()"))

  286. 

  287.         else: # isEnabled()

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

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

  290. 

  291.         painter.restore()

  292. 

  293.     def resizeEvent(self, event):

  294.         self.updateSizes()

  295.         QDial.resizeEvent(self, event)