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

307 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. 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 floor

  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_NO_GRADIENT = 5

  39. 

  40.     # enum Orientation

  41.     HORIZONTAL = 0

  42.     VERTICAL   = 1

  43. 

  44.     HOVER_MIN = 0

  45.     HOVER_MAX = 9

  46. 

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

  48.         QDial.__init__(self, parent)

  49. 

  50.         self.fIndex       = index

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

  52.         self.fPixmapNum   = "01"

  53.         self.fCustomPaint = self.CUSTOM_PAINT_NULL

  54. 

  55.         self.fIsHovered = 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 getIndex(self):

  86.         return self.fIndex

  87. 

  88.     def getSize(self):

  89.         return self.fSize

  90. 

  91.     def setCustomPaint(self, paint):

  92.         self.fCustomPaint = paint

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

  94.         self.update()

  95. 

  96.     def setEnabled(self, enabled):

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

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

  99.             self.updateSizes()

  100.             self.update()

  101.         QDial.setEnabled(self, enabled)

  102. 

  103.     def setIndex(self, index):

  104.         self.fIndex = index

  105. 

  106.     def setLabel(self, label):

  107.         self.fLabel = label

  108. 

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

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

  111. 

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

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

  114. 

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

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

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

  118. 

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

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

  121. 

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

  123.         self.update()

  124. 

  125.     def setPixmap(self, pixmapId):

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

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

  128. 

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

  130.             self.fOrientation = self.HORIZONTAL

  131.         else:

  132.             self.fOrientation = self.VERTICAL

  133. 

  134.         self.updateSizes()

  135.         self.update()

  136. 

  137.     def minimumSizeHint(self):

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

  139. 

  140.     def sizeHint(self):

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

  142. 

  143.     def updateSizes(self):

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

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

  146. 

  147.         if self.fWidth < 1:

  148.             self.fWidth = 1

  149. 

  150.         if self.fHeight < 1:

  151.             self.fHeight = 1

  152. 

  153.         if self.fOrientation == self.HORIZONTAL:

  154.             self.fSize  = self.fHeight

  155.             self.fCount = self.fWidth / self.fHeight

  156.         else:

  157.             self.fSize  = self.fWidth

  158.             self.fCount = self.fHeight / self.fWidth

  159. 

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

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

  162. 

  163.     def enterEvent(self, event):

  164.         self.fIsHovered = True

  165.         if self.fHoverStep == self.HOVER_MIN:

  166.             self.fHoverStep = self.HOVER_MIN + 1

  167.         QDial.enterEvent(self, event)

  168. 

  169.     def leaveEvent(self, event):

  170.         self.fIsHovered = False

  171.         if self.fHoverStep == self.HOVER_MAX:

  172.             self.fHoverStep = self.HOVER_MAX - 1

  173.         QDial.leaveEvent(self, event)

  174. 

  175.     def paintEvent(self, event):

  176.         painter = QPainter(self)

  177.         event.accept()

  178. 

  179.         painter.save()

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

  181. 

  182.         if self.fLabel:

  183.             if self.fCustomPaint == self.CUSTOM_PAINT_NULL:

  184.                 painter.setPen(self.fColor2)

  185.                 painter.setBrush(self.fLabelGradient)

  186.                 painter.drawRect(self.fLabelGradientRect)

  187. 

  188.             painter.setFont(self.fLabelFont)

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

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

  191. 

  192.         if self.isEnabled():

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

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

  195. 

  196.             if divider == 0.0:

  197.                 return

  198. 

  199.             value  = current / divider

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

  201. 

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

  203. 

  204.             if self.fOrientation == self.HORIZONTAL:

  205.                 xpos = self.fSize * per

  206.                 ypos = 0.0

  207.             else:

  208.                 xpos = 0.0

  209.                 ypos = self.fSize * per

  210. 

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

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

  213. 

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

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

  216.                 # knob color

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

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

  219. 

  220.                 # draw small circle

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

  222.                 ballPath = QPainterPath()

  223.                 ballPath.addEllipse(ballRect)

  224.                 #painter.drawRect(ballRect)

  225.                 tmpValue  = (0.375 + 0.75*value)

  226.                 ballValue = tmpValue - floor(tmpValue)

  227.                 ballPoint = ballPath.pointAtPercent(ballValue)

  228. 

  229.                 # draw arc

  230.                 startAngle = 216*16

  231.                 spanAngle  = -252*16*value

  232. 

  233.                 if self.fCustomPaint == self.CUSTOM_PAINT_CARLA_WET:

  234.                     painter.setBrush(colorBlue)

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

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

  237. 

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

  239.                     gradient.setColorAt(0.0,   colorBlue)

  240.                     gradient.setColorAt(0.125, colorBlue)

  241.                     gradient.setColorAt(0.625, colorGreen)

  242.                     gradient.setColorAt(0.75,  colorGreen)

  243.                     gradient.setColorAt(0.76,  colorGreen)

  244.                     gradient.setColorAt(1.0,   colorGreen)

  245.                     painter.setBrush(gradient)

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

  247. 

  248.                 else:

  249.                     painter.setBrush(colorBlue)

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

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

  252. 

  253.                     painter.setBrush(colorBlue)

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

  255. 

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

  257. 

  258.             # Custom knobs (L and R)

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

  260.                 # knob color

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

  262. 

  263.                 # draw small circle

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

  265.                 ballPath = QPainterPath()

  266.                 ballPath.addEllipse(ballRect)

  267.                 #painter.drawRect(ballRect)

  268.                 tmpValue  = (0.375 + 0.75*value)

  269.                 ballValue = tmpValue - floor(tmpValue)

  270.                 ballPoint = ballPath.pointAtPercent(ballValue)

  271. 

  272.                 painter.setBrush(color)

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

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

  275. 

  276.                 # draw arc

  277.                 if self.fCustomPaint == self.CUSTOM_PAINT_CARLA_L:

  278.                     startAngle = 216*16

  279.                     spanAngle  = -252.0*16*value

  280.                 elif self.fCustomPaint == self.CUSTOM_PAINT_CARLA_R:

  281.                     startAngle = 324.0*16

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

  283.                 else:

  284.                     return

  285. 

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

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

  288. 

  289.             # Custom knobs

  290.             else:

  291.                 painter.restore()

  292.                 return

  293. 

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

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

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

  297. 

  298.         else: # isEnabled()

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

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

  301. 

  302.         painter.restore()

  303. 

  304.     def resizeEvent(self, event):

  305.         self.updateSizes()

  306.         QDial.resizeEvent(self, event)