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

289 lines
10KB
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 GPL.txt file

  18. 

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

  20. # Imports (Global)

  21. 

  22. from math import floor

  23. from PyQt4.QtCore import Qt, QPointF, QRectF, QTimer, QSize, SLOT

  24. from PyQt4.QtGui import QColor, QConicalGradient, QDial, QFont, QFontMetrics

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

  26. 

  27. # ------------------------------------------------------------------------------------------------------------

  28. # Widget Class

  29. 

  30. class PixmapDial(QDial):

  31.     # enum Orientation

  32.     HORIZONTAL = 0

  33.     VERTICAL   = 1

  34. 

  35.     # enum CustomPaint

  36.     CUSTOM_PAINT_NULL      = 0

  37.     CUSTOM_PAINT_CARLA_WET = 1

  38.     CUSTOM_PAINT_CARLA_VOL = 2

  39.     CUSTOM_PAINT_CARLA_L   = 3

  40.     CUSTOM_PAINT_CARLA_R   = 4

  41. 

  42.     HOVER_MIN = 0

  43.     HOVER_MAX = 9

  44. 

  45.     def __init__(self, parent):

  46.         QDial.__init__(self, parent)

  47. 

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

  49.         self.fPixmapNum   = "01"

  50.         self.fCustomPaint = self.CUSTOM_PAINT_NULL

  51. 

  52.         self.fHovered   = False

  53.         self.fHoverStep = self.HOVER_MIN

  54. 

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

  56.             self.fOrientation = self.HORIZONTAL

  57.         else:

  58.             self.fOrientation = self.VERTICAL

  59. 

  60.         self.fLabel     = ""

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

  62.         self.fLabelFont = QFont()

  63.         self.fLabelFont.setPointSize(6)

  64.         self.fLabelWidth  = 0

  65.         self.fLabelHeight = 0

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

  67. 

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

  69.             # Light background

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

  71.             self.fColor1 = c

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

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

  74.         else:

  75.             # Dark background

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

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

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

  79. 

  80.         self.updateSizes()

  81. 

  82.     def getSize(self):

  83.         return self.fSize

  84. 

  85.     def setCustomPaint(self, paint):

  86.         self.fCustomPaint = paint

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

  88.         self.update()

  89. 

  90.     def setEnabled(self, enabled):

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

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

  93.             self.updateSizes()

  94.             self.update()

  95.         QDial.setEnabled(self, enabled)

  96. 

  97.     def setLabel(self, label):

  98.         self.fLabel = label

  99. 

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

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

  102. 

  103.         self.fLabelPos.setX(float(self.fSize)/2 - float(self.fLabelWidth)/2)

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

  105. 

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

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

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

  109. 

  110.         self.fLabelGradient.setStart(0, float(self.fSize)/2)

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

  112. 

  113.         self.fLabelGradientRect = QRectF(float(self.fSize)/8, float(self.fSize)/2, float(self.fSize)*6/8, self.fSize+self.fLabelHeight+5)

  114.         self.update()

  115. 

  116.     def setPixmap(self, pixmapId):

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

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

  119. 

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

  121.             self.fOrientation = self.HORIZONTAL

  122.         else:

  123.             self.fOrientation = self.VERTICAL

  124. 

  125.         self.updateSizes()

  126.         self.update()

  127. 

  128.     def minimumSizeHint(self):

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

  130. 

  131.     def sizeHint(self):

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

  133. 

  134.     def updateSizes(self):

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

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

  137. 

  138.         if self.fWidth < 1:

  139.             self.fWidth = 1

  140. 

  141.         if self.fHeight < 1:

  142.             self.fHeight = 1

  143. 

  144.         if self.fOrientation == self.HORIZONTAL:

  145.             self.fSize  = self.fHeight

  146.             self.fCount = self.fWidth / self.fHeight

  147.         else:

  148.             self.fSize  = self.fWidth

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

  150. 

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

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

  153. 

  154.     def enterEvent(self, event):

  155.         self.fHovered = True

  156.         if self.fHoverStep  == self.HOVER_MIN:

  157.             self.fHoverStep += 1

  158.         QDial.enterEvent(self, event)

  159. 

  160.     def leaveEvent(self, event):

  161.         self.fHovered = False

  162.         if self.fHoverStep  == self.HOVER_MAX:

  163.             self.fHoverStep -= 1

  164.         QDial.leaveEvent(self, event)

  165. 

  166.     def paintEvent(self, event):

  167.         painter = QPainter(self)

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

  169.         event.accept()

  170. 

  171.         if self.fLabel:

  172.             if self.fCustomPaint == self.CUSTOM_PAINT_NULL:

  173.                 painter.setPen(self.fColor2)

  174.                 painter.setBrush(self.fLabelGradient)

  175.                 painter.drawRect(self.fLabelGradientRect)

  176. 

  177.             painter.setFont(self.fLabelFont)

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

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

  180. 

  181.         if self.isEnabled():

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

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

  184. 

  185.             if divider == 0.0:

  186.                 return

  187. 

  188.             value  = current / divider

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

  190. 

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

  192. 

  193.             if self.fOrientation == self.HORIZONTAL:

  194.                 xpos = self.fSize * per

  195.                 ypos = 0.0

  196.             else:

  197.                 xpos = 0.0

  198.                 ypos = self.fSize * per

  199. 

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

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

  202. 

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

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

  205.                 # knob color

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

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

  208. 

  209.                 # draw small circle

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

  211.                 ballPath = QPainterPath()

  212.                 ballPath.addEllipse(ballRect)

  213.                 #painter.drawRect(ballRect)

  214.                 tmpValue  = (0.375 + 0.75*value)

  215.                 ballValue = tmpValue - floor(tmpValue)

  216.                 ballPoint = ballPath.pointAtPercent(ballValue)

  217. 

  218.                 # draw arc

  219.                 startAngle = 216*16

  220.                 spanAngle  = -252*16*value

  221. 

  222.                 if self.fCustomPaint == self.CUSTOM_PAINT_CARLA_WET:

  223.                     painter.setBrush(colorBlue)

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

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

  226. 

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

  228.                     gradient.setColorAt(0.0,   colorBlue)

  229.                     gradient.setColorAt(0.125, colorBlue)

  230.                     gradient.setColorAt(0.625, colorGreen)

  231.                     gradient.setColorAt(0.75,  colorGreen)

  232.                     gradient.setColorAt(0.76,  colorGreen)

  233.                     gradient.setColorAt(1.0,   colorGreen)

  234.                     painter.setBrush(gradient)

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

  236. 

  237.                 else:

  238.                     painter.setBrush(colorBlue)

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

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

  241. 

  242.                     painter.setBrush(colorBlue)

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

  244. 

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

  246. 

  247.             # Custom knobs (L and R)

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

  249.                 # knob color

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

  251. 

  252.                 # draw small circle

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

  254.                 ballPath = QPainterPath()

  255.                 ballPath.addEllipse(ballRect)

  256.                 #painter.drawRect(ballRect)

  257.                 tmpValue  = (0.375 + 0.75*value)

  258.                 ballValue = tmpValue - floor(tmpValue)

  259.                 ballPoint = ballPath.pointAtPercent(ballValue)

  260. 

  261.                 painter.setBrush(color)

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

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

  264. 

  265.                 # draw arc

  266.                 if self.fCustomPaint == self.CUSTOM_PAINT_CARLA_L:

  267.                     startAngle = 216*16

  268.                     spanAngle  = -252.0*16*value

  269.                 elif self.fCustomPaint == self.CUSTOM_PAINT_CARLA_R:

  270.                     startAngle = 324.0*16

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

  272.                 else:

  273.                     return

  274. 

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

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

  277. 

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

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

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

  281. 

  282.         else: # isEnabled()

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

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

  285. 

  286.     def resizeEvent(self, event):

  287.         self.updateSizes()

  288.         QDial.resizeEvent(self, event)