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.
1458 Commits
17 Branches
940MB
Tree: 1cff73d3ef
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '1cff73d3ef'
${ noResults }
Carla/source/widgets/pixmapdial.py

359 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() #"DejaVu Sans [Book]", 6, QFont.Normal, False)

  70.         #self.fLabelFont.setPixelSize(8)

  71.         #self.fLabelFont.setWeight(100)

  72.         self.fLabelFont.setPointSize(6)

  73.         self.fLabelWidth  = 0

  74.         self.fLabelHeight = 0

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

  76. 

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

  78.             # Light background

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

  80.             self.fColor1 = c

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

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

  83.         else:

  84.             # Dark background

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

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

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

  88. 

  89.         self.updateSizes()

  90. 

  91.     def getIndex(self):

  92.         return self.fIndex

  93. 

  94.     def getSize(self):

  95.         return self.fSize

  96. 

  97.     def setCustomColor(self, color):

  98.         self.fCustomColor = color

  99.         #self.update()

  100. 

  101.     def setCustomPaint(self, paint):

  102.         self.fCustomPaint = paint

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

  104.         #self.update()

  105. 

  106.     def setEnabled(self, enabled):

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

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

  109.             self.updateSizes()

  110.             self.update()

  111.         QDial.setEnabled(self, enabled)

  112. 

  113.     def setIndex(self, index):

  114.         self.fIndex = index

  115. 

  116.     def setLabel(self, label):

  117.         self.fLabel = label

  118. 

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

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

  121. 

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

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

  124. 

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

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

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

  128. 

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

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

  131. 

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

  133.         #self.update()

  134. 

  135.     def setPixmap(self, pixmapId):

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

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

  138. 

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

  140.             self.fOrientation = self.HORIZONTAL

  141.         else:

  142.             self.fOrientation = self.VERTICAL

  143. 

  144.         self.updateSizes()

  145.         #self.update()

  146. 

  147.     def setWhiteText(self):

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

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

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

  151. 

  152.     def minimumSizeHint(self):

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

  154. 

  155.     def sizeHint(self):

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

  157. 

  158.     def updateSizes(self):

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

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

  161. 

  162.         if self.fWidth < 1:

  163.             self.fWidth = 1

  164. 

  165.         if self.fHeight < 1:

  166.             self.fHeight = 1

  167. 

  168.         if self.fOrientation == self.HORIZONTAL:

  169.             self.fSize  = self.fHeight

  170.             self.fCount = self.fWidth / self.fHeight

  171.         else:

  172.             self.fSize  = self.fWidth

  173.             self.fCount = self.fHeight / self.fWidth

  174. 

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

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

  177. 

  178.     def enterEvent(self, event):

  179.         self.fIsHovered = True

  180.         if self.fHoverStep == self.HOVER_MIN:

  181.             self.fHoverStep = self.HOVER_MIN + 1

  182.         QDial.enterEvent(self, event)

  183. 

  184.     def leaveEvent(self, event):

  185.         self.fIsHovered = False

  186.         if self.fHoverStep == self.HOVER_MAX:

  187.             self.fHoverStep = self.HOVER_MAX - 1

  188.         QDial.leaveEvent(self, event)

  189. 

  190.     def paintEvent(self, event):

  191.         painter = QPainter(self)

  192.         event.accept()

  193. 

  194.         painter.save()

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

  196. 

  197.         if self.fLabel:

  198.             if self.fCustomPaint == self.CUSTOM_PAINT_NULL:

  199.                 painter.setPen(self.fColor2)

  200.                 painter.setBrush(self.fLabelGradient)

  201.                 painter.drawRect(self.fLabelGradientRect)

  202. 

  203.             painter.setFont(self.fLabelFont)

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

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

  206. 

  207.         if self.isEnabled():

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

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

  210. 

  211.             if divider == 0.0:

  212.                 return

  213. 

  214.             value  = current / divider

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

  216. 

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

  218. 

  219.             if self.fOrientation == self.HORIZONTAL:

  220.                 xpos = self.fSize * per

  221.                 ypos = 0.0

  222.             else:

  223.                 xpos = 0.0

  224.                 ypos = self.fSize * per

  225. 

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

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

  228. 

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

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

  231.                 # knob color

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

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

  234. 

  235.                 # draw small circle

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

  237.                 ballPath = QPainterPath()

  238.                 ballPath.addEllipse(ballRect)

  239.                 #painter.drawRect(ballRect)

  240.                 tmpValue  = (0.375 + 0.75*value)

  241.                 ballValue = tmpValue - floor(tmpValue)

  242.                 ballPoint = ballPath.pointAtPercent(ballValue)

  243. 

  244.                 # draw arc

  245.                 startAngle = 216*16

  246.                 spanAngle  = -252*16*value

  247. 

  248.                 if self.fCustomPaint == self.CUSTOM_PAINT_CARLA_WET:

  249.                     painter.setBrush(colorBlue)

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

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

  252. 

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

  254.                     gradient.setColorAt(0.0,   colorBlue)

  255.                     gradient.setColorAt(0.125, colorBlue)

  256.                     gradient.setColorAt(0.625, colorGreen)

  257.                     gradient.setColorAt(0.75,  colorGreen)

  258.                     gradient.setColorAt(0.76,  colorGreen)

  259.                     gradient.setColorAt(1.0,   colorGreen)

  260.                     painter.setBrush(gradient)

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

  262. 

  263.                 else:

  264.                     painter.setBrush(colorBlue)

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

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

  267. 

  268.                     painter.setBrush(colorBlue)

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

  270. 

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

  272. 

  273.             # Custom knobs (L and R)

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

  275.                 # knob color

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

  277. 

  278.                 # draw small circle

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

  280.                 ballPath = QPainterPath()

  281.                 ballPath.addEllipse(ballRect)

  282.                 #painter.drawRect(ballRect)

  283.                 tmpValue  = (0.375 + 0.75*value)

  284.                 ballValue = tmpValue - floor(tmpValue)

  285.                 ballPoint = ballPath.pointAtPercent(ballValue)

  286. 

  287.                 painter.setBrush(color)

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

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

  290. 

  291.                 # draw arc

  292.                 if self.fCustomPaint == self.CUSTOM_PAINT_CARLA_L:

  293.                     startAngle = 216*16

  294.                     spanAngle  = -252.0*16*value

  295.                 elif self.fCustomPaint == self.CUSTOM_PAINT_CARLA_R:

  296.                     startAngle = 324.0*16

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

  298.                 else:

  299.                     return

  300. 

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

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

  303. 

  304.             # Custom knobs (Color)

  305.             elif self.fCustomPaint == self.CUSTOM_PAINT_COLOR:

  306.                 # knob color

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

  308. 

  309.                 # draw small circle

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

  311.                 ballPath = QPainterPath()

  312.                 ballPath.addEllipse(ballRect)

  313.                 tmpValue  = (0.375 + 0.75*value)

  314.                 ballValue = tmpValue - floor(tmpValue)

  315.                 ballPoint = ballPath.pointAtPercent(ballValue)

  316. 

  317.                 # draw arc

  318.                 startAngle = 216*16

  319.                 spanAngle  = -252*16*value

  320. 

  321.                 painter.setBrush(color)

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

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

  324. 

  325.                 painter.setBrush(color)

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

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

  328. 

  329.             # Custom knobs (Zita)

  330.             elif self.fCustomPaint == self.CUSTOM_PAINT_ZITA:

  331.                 a = value * pi * 1.5 - 2.35

  332.                 r = 10.0

  333.                 x = 10.5

  334.                 y = 10.5

  335.                 x += r * sin(a)

  336.                 y -= r * cos(a)

  337.                 painter.setBrush(Qt.black)

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

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

  340. 

  341.             # Custom knobs

  342.             else:

  343.                 painter.restore()

  344.                 return

  345. 

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

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

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

  349. 

  350.         else: # isEnabled()

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

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

  353. 

  354.         painter.restore()

  355. 

  356.     def resizeEvent(self, event):

  357.         self.updateSizes()

  358.         QDial.resizeEvent(self, event)