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

290 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 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.m_pixmap = QPixmap(":/bitmaps/dial_01d.png")

  49.         self.m_pixmapNum   = "01"

  50.         self.m_customPaint = self.CUSTOM_PAINT_NULL

  51. 

  52.         self.m_hovered   = False

  53.         self.m_hoverStep = self.HOVER_MIN

  54. 

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

  56.             self.m_orientation = self.HORIZONTAL

  57.         else:

  58.             self.m_orientation = self.VERTICAL

  59. 

  60.         self.m_label = ""

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

  62.         self.m_labelFont = QFont()

  63.         self.m_labelFont.setPointSize(6)

  64.         self.m_labelWidth  = 0

  65.         self.m_labelHeight = 0

  66.         self.m_labelGradient = 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.m_color1 = c

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

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

  74.         else:

  75.             # Dark background

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

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

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

  79. 

  80.         self.updateSizes()

  81. 

  82.     def getSize(self):

  83.         return self.p_size

  84. 

  85.     def setCustomPaint(self, paint):

  86.         self.m_customPaint = paint

  87.         self.m_labelPos.setY(self.p_size + self.m_labelHeight/2)

  88.         self.update()

  89. 

  90.     def setEnabled(self, enabled):

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

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

  93.             self.updateSizes()

  94.             self.update()

  95.         QDial.setEnabled(self, enabled)

  96. 

  97.     def setLabel(self, label):

  98.         self.m_label = label

  99. 

  100.         self.m_labelWidth  = QFontMetrics(self.m_labelFont).width(label)

  101.         self.m_labelHeight = QFontMetrics(self.m_labelFont).height()

  102. 

  103.         self.m_labelPos.setX(float(self.p_size)/2 - float(self.m_labelWidth)/2)

  104.         self.m_labelPos.setY(self.p_size + self.m_labelHeight)

  105. 

  106.         self.m_labelGradient.setColorAt(0.0, self.m_color1)

  107.         self.m_labelGradient.setColorAt(0.6, self.m_color1)

  108.         self.m_labelGradient.setColorAt(1.0, self.m_color2)

  109. 

  110.         self.m_labelGradient.setStart(0, float(self.p_size)/2)

  111.         self.m_labelGradient.setFinalStop(0, self.p_size + self.m_labelHeight + 5)

  112. 

  113.         self.m_labelGradient_rect = QRectF(float(self.p_size)/8, float(self.p_size)/2, float(self.p_size)*6/8, self.p_size+self.m_labelHeight+5)

  114.         self.update()

  115. 

  116.     def setPixmap(self, pixmapId):

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

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

  119. 

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

  121.             self.m_orientation = self.HORIZONTAL

  122.         else:

  123.             self.m_orientation = self.VERTICAL

  124. 

  125.         self.updateSizes()

  126.         self.update()

  127. 

  128.     def minimumSizeHint(self):

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

  130. 

  131.     def sizeHint(self):

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

  133. 

  134.     def updateSizes(self):

  135.         self.p_width  = self.m_pixmap.width()

  136.         self.p_height = self.m_pixmap.height()

  137. 

  138.         if self.p_width < 1:

  139.             self.p_width = 1

  140. 

  141.         if self.p_height < 1:

  142.             self.p_height = 1

  143. 

  144.         if self.m_orientation == self.HORIZONTAL:

  145.             self.p_size  = self.p_height

  146.             self.p_count = self.p_width / self.p_height

  147.         else:

  148.             self.p_size  = self.p_width

  149.             self.p_count = self.p_height / self.p_width

  150. 

  151.         self.setMinimumSize(self.p_size, self.p_size + self.m_labelHeight + 5)

  152.         self.setMaximumSize(self.p_size, self.p_size + self.m_labelHeight + 5)

  153. 

  154.     def enterEvent(self, event):

  155.         self.m_hovered = True

  156.         if self.m_hoverStep  == self.HOVER_MIN:

  157.             self.m_hoverStep += 1

  158.         QDial.enterEvent(self, event)

  159. 

  160.     def leaveEvent(self, event):

  161.         self.m_hovered = False

  162.         if self.m_hoverStep  == self.HOVER_MAX:

  163.             self.m_hoverStep -= 1

  164.         QDial.leaveEvent(self, event)

  165. 

  166.     def paintEvent(self, event):

  167.         painter = QPainter(self)

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

  169. 

  170.         if self.m_label:

  171.             if self.m_customPaint == self.CUSTOM_PAINT_NULL:

  172.                 painter.setPen(self.m_color2)

  173.                 painter.setBrush(self.m_labelGradient)

  174.                 painter.drawRect(self.m_labelGradient_rect)

  175. 

  176.             painter.setFont(self.m_labelFont)

  177.             painter.setPen(self.m_colorT[0 if self.isEnabled() else 1])

  178.             painter.drawText(self.m_labelPos, self.m_label)

  179. 

  180.         if self.isEnabled():

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

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

  183. 

  184.             if divider == 0.0:

  185.                 return

  186. 

  187.             value  = current / divider

  188.             target = QRectF(0.0, 0.0, self.p_size, self.p_size)

  189. 

  190.             per = int((self.p_count - 1) * value)

  191. 

  192.             if self.m_orientation == self.HORIZONTAL:

  193.                 xpos = self.p_size * per

  194.                 ypos = 0.0

  195.             else:

  196.                 xpos = 0.0

  197.                 ypos = self.p_size * per

  198. 

  199.             source = QRectF(xpos, ypos, self.p_size, self.p_size)

  200.             painter.drawPixmap(target, self.m_pixmap, source)

  201. 

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

  203.             if self.m_customPaint in (self.CUSTOM_PAINT_CARLA_WET, self.CUSTOM_PAINT_CARLA_VOL):

  204.                 # knob color

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

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

  207. 

  208.                 # draw small circle

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

  210.                 ballPath = QPainterPath()

  211.                 ballPath.addEllipse(ballRect)

  212.                 #painter.drawRect(ballRect)

  213.                 tmpValue  = (0.375 + 0.75*value)

  214.                 ballValue = tmpValue - floor(tmpValue)

  215.                 ballPoint = ballPath.pointAtPercent(ballValue)

  216. 

  217.                 # draw arc

  218.                 startAngle = 216*16

  219.                 spanAngle  = -252*16*value

  220. 

  221.                 if self.m_customPaint == self.CUSTOM_PAINT_CARLA_WET:

  222.                     painter.setBrush(colorBlue)

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

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

  225. 

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

  227.                     gradient.setColorAt(0.0,   colorBlue)

  228.                     gradient.setColorAt(0.125, colorBlue)

  229.                     gradient.setColorAt(0.625, colorGreen)

  230.                     gradient.setColorAt(0.75,  colorGreen)

  231.                     gradient.setColorAt(0.76,  colorGreen)

  232.                     gradient.setColorAt(1.0,   colorGreen)

  233.                     painter.setBrush(gradient)

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

  235. 

  236.                 else:

  237.                     painter.setBrush(colorBlue)

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

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

  240. 

  241.                     painter.setBrush(colorBlue)

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

  243. 

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

  245. 

  246.             # Custom knobs (L and R)

  247.             elif self.m_customPaint in (self.CUSTOM_PAINT_CARLA_L, self.CUSTOM_PAINT_CARLA_R):

  248.                 # knob color

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

  250. 

  251.                 # draw small circle

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

  253.                 ballPath = QPainterPath()

  254.                 ballPath.addEllipse(ballRect)

  255.                 #painter.drawRect(ballRect)

  256.                 tmpValue  = (0.375 + 0.75*value)

  257.                 ballValue = tmpValue - floor(tmpValue)

  258.                 ballPoint = ballPath.pointAtPercent(ballValue)

  259. 

  260.                 painter.setBrush(color)

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

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

  263. 

  264.                 # draw arc

  265.                 if self.m_customPaint == self.CUSTOM_PAINT_CARLA_L:

  266.                     startAngle = 216*16

  267.                     spanAngle  = -252.0*16*value

  268.                 elif self.m_customPaint == self.CUSTOM_PAINT_CARLA_R:

  269.                     startAngle = 324.0*16

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

  271.                 else:

  272.                     return

  273. 

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

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

  276. 

  277.             if self.HOVER_MIN < self.m_hoverStep < self.HOVER_MAX:

  278.                 self.m_hoverStep += 1 if self.m_hovered else -1

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

  280. 

  281.         else:

  282.             target = QRectF(0.0, 0.0, self.p_size, self.p_size)

  283.             painter.drawPixmap(target, self.m_pixmap, target)

  284. 

  285.         event.accept()

  286. 

  287.     def resizeEvent(self, event):

  288.         self.updateSizes()

  289.         QDial.resizeEvent(self, event)