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.
1473 Commits
16 Branches
14GB
Tree: 567a2f455b
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '567a2f455b'
${ noResults }
Carla/source/widgets/pixmapdial.py

357 lines
13KB
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(self.font())

  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 setWhiteText(self):

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

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

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

  149. 

  150.     def minimumSizeHint(self):

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

  152. 

  153.     def sizeHint(self):

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

  155. 

  156.     def updateSizes(self):

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

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

  159. 

  160.         if self.fWidth < 1:

  161.             self.fWidth = 1

  162. 

  163.         if self.fHeight < 1:

  164.             self.fHeight = 1

  165. 

  166.         if self.fOrientation == self.HORIZONTAL:

  167.             self.fSize  = self.fHeight

  168.             self.fCount = self.fWidth / self.fHeight

  169.         else:

  170.             self.fSize  = self.fWidth

  171.             self.fCount = self.fHeight / self.fWidth

  172. 

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

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

  175. 

  176.     def enterEvent(self, event):

  177.         self.fIsHovered = True

  178.         if self.fHoverStep == self.HOVER_MIN:

  179.             self.fHoverStep = self.HOVER_MIN + 1

  180.         QDial.enterEvent(self, event)

  181. 

  182.     def leaveEvent(self, event):

  183.         self.fIsHovered = False

  184.         if self.fHoverStep == self.HOVER_MAX:

  185.             self.fHoverStep = self.HOVER_MAX - 1

  186.         QDial.leaveEvent(self, event)

  187. 

  188.     def paintEvent(self, event):

  189.         painter = QPainter(self)

  190.         event.accept()

  191. 

  192.         painter.save()

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

  194. 

  195.         if self.fLabel:

  196.             if self.fCustomPaint == self.CUSTOM_PAINT_NULL:

  197.                 painter.setPen(self.fColor2)

  198.                 painter.setBrush(self.fLabelGradient)

  199.                 painter.drawRect(self.fLabelGradientRect)

  200. 

  201.             painter.setFont(self.fLabelFont)

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

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

  204. 

  205.         if self.isEnabled():

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

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

  208. 

  209.             if divider == 0.0:

  210.                 return

  211. 

  212.             value  = current / divider

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

  214. 

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

  216. 

  217.             if self.fOrientation == self.HORIZONTAL:

  218.                 xpos = self.fSize * per

  219.                 ypos = 0.0

  220.             else:

  221.                 xpos = 0.0

  222.                 ypos = self.fSize * per

  223. 

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

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

  226. 

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

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

  229.                 # knob color

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

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

  232. 

  233.                 # draw small circle

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

  235.                 ballPath = QPainterPath()

  236.                 ballPath.addEllipse(ballRect)

  237.                 #painter.drawRect(ballRect)

  238.                 tmpValue  = (0.375 + 0.75*value)

  239.                 ballValue = tmpValue - floor(tmpValue)

  240.                 ballPoint = ballPath.pointAtPercent(ballValue)

  241. 

  242.                 # draw arc

  243.                 startAngle = 216*16

  244.                 spanAngle  = -252*16*value

  245. 

  246.                 if self.fCustomPaint == self.CUSTOM_PAINT_CARLA_WET:

  247.                     painter.setBrush(colorBlue)

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

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

  250. 

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

  252.                     gradient.setColorAt(0.0,   colorBlue)

  253.                     gradient.setColorAt(0.125, colorBlue)

  254.                     gradient.setColorAt(0.625, colorGreen)

  255.                     gradient.setColorAt(0.75,  colorGreen)

  256.                     gradient.setColorAt(0.76,  colorGreen)

  257.                     gradient.setColorAt(1.0,   colorGreen)

  258.                     painter.setBrush(gradient)

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

  260. 

  261.                 else:

  262.                     painter.setBrush(colorBlue)

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

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

  265. 

  266.                     painter.setBrush(colorBlue)

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

  268. 

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

  270. 

  271.             # Custom knobs (L and R)

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

  273.                 # knob color

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

  275. 

  276.                 # draw small circle

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

  278.                 ballPath = QPainterPath()

  279.                 ballPath.addEllipse(ballRect)

  280.                 #painter.drawRect(ballRect)

  281.                 tmpValue  = (0.375 + 0.75*value)

  282.                 ballValue = tmpValue - floor(tmpValue)

  283.                 ballPoint = ballPath.pointAtPercent(ballValue)

  284. 

  285.                 painter.setBrush(color)

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

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

  288. 

  289.                 # draw arc

  290.                 if self.fCustomPaint == self.CUSTOM_PAINT_CARLA_L:

  291.                     startAngle = 216*16

  292.                     spanAngle  = -252.0*16*value

  293.                 elif self.fCustomPaint == self.CUSTOM_PAINT_CARLA_R:

  294.                     startAngle = 324.0*16

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

  296.                 else:

  297.                     return

  298. 

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

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

  301. 

  302.             # Custom knobs (Color)

  303.             elif self.fCustomPaint == self.CUSTOM_PAINT_COLOR:

  304.                 # knob color

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

  306. 

  307.                 # draw small circle

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

  309.                 ballPath = QPainterPath()

  310.                 ballPath.addEllipse(ballRect)

  311.                 tmpValue  = (0.375 + 0.75*value)

  312.                 ballValue = tmpValue - floor(tmpValue)

  313.                 ballPoint = ballPath.pointAtPercent(ballValue)

  314. 

  315.                 # draw arc

  316.                 startAngle = 216*16

  317.                 spanAngle  = -252*16*value

  318. 

  319.                 painter.setBrush(color)

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

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

  322. 

  323.                 painter.setBrush(color)

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

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

  326. 

  327.             # Custom knobs (Zita)

  328.             elif self.fCustomPaint == self.CUSTOM_PAINT_ZITA:

  329.                 a = value * pi * 1.5 - 2.35

  330.                 r = 10.0

  331.                 x = 10.5

  332.                 y = 10.5

  333.                 x += r * sin(a)

  334.                 y -= r * cos(a)

  335.                 painter.setBrush(Qt.black)

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

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

  338. 

  339.             # Custom knobs

  340.             else:

  341.                 painter.restore()

  342.                 return

  343. 

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

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

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

  347. 

  348.         else: # isEnabled()

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

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

  351. 

  352.         painter.restore()

  353. 

  354.     def resizeEvent(self, event):

  355.         self.updateSizes()

  356.         QDial.resizeEvent(self, event)