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.
1447 Commits
16 Branches
141MB
Tree: 2b01dd9b33
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '2b01dd9b33'
${ noResults }
Carla/source/widgets/pixmapdial.py

352 lines
12KB
Raw Blame History 

  1. #!/usr/bin/env python3

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

  3. 

  4. # Pixmap Dial, a custom Qt4 widget

  5. # Copyright (C) 2011-2014 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 PyQt4.QtCore import Qt, QPointF, QRectF, QTimer, QSize

  23. from PyQt4.QtGui import QColor, QConicalGradient, QFont, QFontMetrics

  24. from PyQt4.QtGui import QDial, QLinearGradient, QPainter, QPainterPath, QPen, QPixmap

  25. 

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

  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.     CUSTOM_PAINT_COLOR       = 5

  39.     CUSTOM_PAINT_ZITA        = 6

  40.     CUSTOM_PAINT_NO_GRADIENT = 7

  41. 

  42.     # enum Orientation

  43.     HORIZONTAL = 0

  44.     VERTICAL   = 1

  45. 

  46.     HOVER_MIN = 0

  47.     HOVER_MAX = 9

  48. 

  49.     def __init__(self, parent, index=0):

  50.         QDial.__init__(self, parent)

  51. 

  52.         self.fIndex       = index

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

  54.         self.fPixmapNum   = "01"

  55. 

  56.         self.fCustomColor = QColor(0, 0, 0)

  57.         self.fCustomPaint = self.CUSTOM_PAINT_NULL

  58. 

  59.         self.fIsHovered = False

  60.         self.fHoverStep = self.HOVER_MIN

  61. 

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

  63.             self.fOrientation = self.HORIZONTAL

  64.         else:

  65.             self.fOrientation = self.VERTICAL

  66. 

  67.         self.fLabel     = ""

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

  69.         self.fLabelFont = QFont()

  70.         self.fLabelFont.setPointSize(6)

  71.         self.fLabelWidth  = 0

  72.         self.fLabelHeight = 0

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

  74. 

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

  76.             # Light background

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

  78.             self.fColor1 = c

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

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

  81.         else:

  82.             # Dark background

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

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

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

  86. 

  87.         self.updateSizes()

  88. 

  89.     def getIndex(self):

  90.         return self.fIndex

  91. 

  92.     def getSize(self):

  93.         return self.fSize

  94. 

  95.     def setCustomColor(self, color):

  96.         self.fCustomColor = color

  97.         #self.update()

  98. 

  99.     def setCustomPaint(self, paint):

  100.         self.fCustomPaint = paint

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

  102.         #self.update()

  103. 

  104.     def setEnabled(self, enabled):

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

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

  107.             self.updateSizes()

  108.             self.update()

  109.         QDial.setEnabled(self, enabled)

  110. 

  111.     def setIndex(self, index):

  112.         self.fIndex = index

  113. 

  114.     def setLabel(self, label):

  115.         self.fLabel = label

  116. 

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

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

  119. 

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

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

  122. 

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

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

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

  126. 

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

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

  129. 

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

  131.         #self.update()

  132. 

  133.     def setPixmap(self, pixmapId):

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

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

  136. 

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

  138.             self.fOrientation = self.HORIZONTAL

  139.         else:

  140.             self.fOrientation = self.VERTICAL

  141. 

  142.         self.updateSizes()

  143.         #self.update()

  144. 

  145.     def minimumSizeHint(self):

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

  147. 

  148.     def sizeHint(self):

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

  150. 

  151.     def updateSizes(self):

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

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

  154. 

  155.         if self.fWidth < 1:

  156.             self.fWidth = 1

  157. 

  158.         if self.fHeight < 1:

  159.             self.fHeight = 1

  160. 

  161.         if self.fOrientation == self.HORIZONTAL:

  162.             self.fSize  = self.fHeight

  163.             self.fCount = self.fWidth / self.fHeight

  164.         else:

  165.             self.fSize  = self.fWidth

  166.             self.fCount = self.fHeight / self.fWidth

  167. 

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

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

  170. 

  171.     def enterEvent(self, event):

  172.         self.fIsHovered = True

  173.         if self.fHoverStep == self.HOVER_MIN:

  174.             self.fHoverStep = self.HOVER_MIN + 1

  175.         QDial.enterEvent(self, event)

  176. 

  177.     def leaveEvent(self, event):

  178.         self.fIsHovered = False

  179.         if self.fHoverStep == self.HOVER_MAX:

  180.             self.fHoverStep = self.HOVER_MAX - 1

  181.         QDial.leaveEvent(self, event)

  182. 

  183.     def paintEvent(self, event):

  184.         painter = QPainter(self)

  185.         event.accept()

  186. 

  187.         painter.save()

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

  189. 

  190.         if self.fLabel:

  191.             if self.fCustomPaint == self.CUSTOM_PAINT_NULL:

  192.                 painter.setPen(self.fColor2)

  193.                 painter.setBrush(self.fLabelGradient)

  194.                 painter.drawRect(self.fLabelGradientRect)

  195. 

  196.             painter.setFont(self.fLabelFont)

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

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

  199. 

  200.         if self.isEnabled():

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

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

  203. 

  204.             if divider == 0.0:

  205.                 return

  206. 

  207.             value  = current / divider

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

  209. 

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

  211. 

  212.             if self.fOrientation == self.HORIZONTAL:

  213.                 xpos = self.fSize * per

  214.                 ypos = 0.0

  215.             else:

  216.                 xpos = 0.0

  217.                 ypos = self.fSize * per

  218. 

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

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

  221. 

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

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

  224.                 # knob color

  225.                 colorGreen = QColor(0x5D, 0xE7, 0x3D).lighter(100 + self.fHoverStep*6)

  226.                 colorBlue  = QColor(0x3E, 0xB8, 0xBE).lighter(100 + self.fHoverStep*6)

  227. 

  228.                 # draw small circle

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

  230.                 ballPath = QPainterPath()

  231.                 ballPath.addEllipse(ballRect)

  232.                 #painter.drawRect(ballRect)

  233.                 tmpValue  = (0.375 + 0.75*value)

  234.                 ballValue = tmpValue - floor(tmpValue)

  235.                 ballPoint = ballPath.pointAtPercent(ballValue)

  236. 

  237.                 # draw arc

  238.                 startAngle = 216*16

  239.                 spanAngle  = -252*16*value

  240. 

  241.                 if self.fCustomPaint == self.CUSTOM_PAINT_CARLA_WET:

  242.                     painter.setBrush(colorBlue)

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

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

  245. 

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

  247.                     gradient.setColorAt(0.0,   colorBlue)

  248.                     gradient.setColorAt(0.125, colorBlue)

  249.                     gradient.setColorAt(0.625, colorGreen)

  250.                     gradient.setColorAt(0.75,  colorGreen)

  251.                     gradient.setColorAt(0.76,  colorGreen)

  252.                     gradient.setColorAt(1.0,   colorGreen)

  253.                     painter.setBrush(gradient)

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

  255. 

  256.                 else:

  257.                     painter.setBrush(colorBlue)

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

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

  260. 

  261.                     painter.setBrush(colorBlue)

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

  263. 

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

  265. 

  266.             # Custom knobs (L and R)

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

  268.                 # knob color

  269.                 color = QColor(0xAD, 0xD5, 0x48).lighter(100 + self.fHoverStep*6)

  270. 

  271.                 # draw small circle

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

  273.                 ballPath = QPainterPath()

  274.                 ballPath.addEllipse(ballRect)

  275.                 #painter.drawRect(ballRect)

  276.                 tmpValue  = (0.375 + 0.75*value)

  277.                 ballValue = tmpValue - floor(tmpValue)

  278.                 ballPoint = ballPath.pointAtPercent(ballValue)

  279. 

  280.                 painter.setBrush(color)

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

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

  283. 

  284.                 # draw arc

  285.                 if self.fCustomPaint == self.CUSTOM_PAINT_CARLA_L:

  286.                     startAngle = 216*16

  287.                     spanAngle  = -252.0*16*value

  288.                 elif self.fCustomPaint == self.CUSTOM_PAINT_CARLA_R:

  289.                     startAngle = 324.0*16

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

  291.                 else:

  292.                     return

  293. 

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

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

  296. 

  297.             # Custom knobs (Color)

  298.             elif self.fCustomPaint == self.CUSTOM_PAINT_COLOR:

  299.                 # knob color

  300.                 color = self.fCustomColor.lighter(100 + self.fHoverStep*6)

  301. 

  302.                 # draw small circle

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

  304.                 ballPath = QPainterPath()

  305.                 ballPath.addEllipse(ballRect)

  306.                 tmpValue  = (0.375 + 0.75*value)

  307.                 ballValue = tmpValue - floor(tmpValue)

  308.                 ballPoint = ballPath.pointAtPercent(ballValue)

  309. 

  310.                 # draw arc

  311.                 startAngle = 216*16

  312.                 spanAngle  = -252*16*value

  313. 

  314.                 painter.setBrush(color)

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

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

  317. 

  318.                 painter.setBrush(color)

  319.                 painter.setPen(QPen(color, 3))

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

  321. 

  322.             # Custom knobs (Zita)

  323.             elif self.fCustomPaint == self.CUSTOM_PAINT_ZITA:

  324.                 a = value * pi * 1.5 - 2.35

  325.                 r = 10.0

  326.                 x = 10.5

  327.                 y = 10.5

  328.                 x += r * sin(a)

  329.                 y -= r * cos(a)

  330.                 painter.setBrush(Qt.black)

  331.                 painter.setPen(QPen(Qt.black, 2))

  332.                 painter.drawLine(QPointF(11.0, 11.0), QPointF(x, y))

  333. 

  334.             # Custom knobs

  335.             else:

  336.                 painter.restore()

  337.                 return

  338. 

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

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

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

  342. 

  343.         else: # isEnabled()

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

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

  346. 

  347.         painter.restore()

  348. 

  349.     def resizeEvent(self, event):

  350.         self.updateSizes()

  351.         QDial.resizeEvent(self, event)