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

284 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 modify

  8. # it under the terms of the GNU General Public License as published by

  9. # the Free Software Foundation; either version 2 of the License, or

  10. # 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 COPYING 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, QFontMetrics, QLinearGradient, QPainter, QPainterPath, QPen, QPixmap

  25. 

  26. # ------------------------------------------------------------------------------------------------------------

  27. # Widget Class

  28. 

  29. class PixmapDial(QDial):

  30.     # enum Orientation

  31.     HORIZONTAL = 0

  32.     VERTICAL   = 1

  33. 

  34.     # enum CustomPaint

  35.     CUSTOM_PAINT_NULL      = 0

  36.     CUSTOM_PAINT_CARLA_WET = 1

  37.     CUSTOM_PAINT_CARLA_VOL = 2

  38.     CUSTOM_PAINT_CARLA_L   = 3

  39.     CUSTOM_PAINT_CARLA_R   = 4

  40. 

  41.     HOVER_MIN = 0

  42.     HOVER_MAX = 9

  43. 

  44.     def __init__(self, parent):

  45.         QDial.__init__(self, parent)

  46. 

  47.         self.m_pixmap = QPixmap(":/bitmaps/dial_01d.png")

  48.         self.m_pixmapNum   = "01"

  49.         self.m_customPaint = self.CUSTOM_PAINT_NULL

  50. 

  51.         self.m_hovered   = False

  52.         self.m_hoverStep = self.HOVER_MIN

  53. 

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

  55.             self.m_orientation = self.HORIZONTAL

  56.         else:

  57.             self.m_orientation = self.VERTICAL

  58. 

  59.         self.m_label = ""

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

  61.         self.m_labelWidth  = 0

  62.         self.m_labelHeight = 0

  63.         self.m_labelGradient = QLinearGradient(0, 0, 0, 1)

  64. 

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

  66.             # Light background

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

  68.             self.m_color1 = c

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

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

  71.         else:

  72.             # Dark background

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

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

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

  76. 

  77.         self.updateSizes()

  78. 

  79.     def getSize(self):

  80.         return self.p_size

  81. 

  82.     def setCustomPaint(self, paint):

  83.         self.m_customPaint = paint

  84.         self.update()

  85. 

  86.     def setEnabled(self, enabled):

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

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

  89.             self.updateSizes()

  90.             self.update()

  91.         QDial.setEnabled(self, enabled)

  92. 

  93.     def setLabel(self, label):

  94.         self.m_label = label

  95. 

  96.         self.m_labelWidth  = QFontMetrics(self.font()).width(label)

  97.         self.m_labelHeight = QFontMetrics(self.font()).height()

  98. 

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

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

  101. 

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

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

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

  105. 

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

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

  108. 

  109.         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)

  110.         self.update()

  111. 

  112.     def setPixmap(self, pixmapId):

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

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

  115. 

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

  117.             self.m_orientation = self.HORIZONTAL

  118.         else:

  119.             self.m_orientation = self.VERTICAL

  120. 

  121.         self.updateSizes()

  122.         self.update()

  123. 

  124.     def minimumSizeHint(self):

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

  126. 

  127.     def sizeHint(self):

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

  129. 

  130.     def updateSizes(self):

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

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

  133. 

  134.         if self.p_width < 1:

  135.             self.p_width = 1

  136. 

  137.         if self.p_height < 1:

  138.             self.p_height = 1

  139. 

  140.         if self.m_orientation == self.HORIZONTAL:

  141.             self.p_size  = self.p_height

  142.             self.p_count = self.p_width / self.p_height

  143.         else:

  144.             self.p_size  = self.p_width

  145.             self.p_count = self.p_height / self.p_width

  146. 

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

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

  149. 

  150.     def enterEvent(self, event):

  151.         self.m_hovered = True

  152.         if self.m_hoverStep  == self.HOVER_MIN:

  153.             self.m_hoverStep += 1

  154.         QDial.enterEvent(self, event)

  155. 

  156.     def leaveEvent(self, event):

  157.         self.m_hovered = False

  158.         if self.m_hoverStep  == self.HOVER_MAX:

  159.             self.m_hoverStep -= 1

  160.         QDial.leaveEvent(self, event)

  161. 

  162.     def paintEvent(self, event):

  163.         painter = QPainter(self)

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

  165. 

  166.         if self.m_label:

  167.             painter.setPen(self.m_color2)

  168.             painter.setBrush(self.m_labelGradient)

  169.             painter.drawRect(self.m_labelGradient_rect)

  170. 

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

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

  173. 

  174.         if self.isEnabled():

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

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

  177. 

  178.             if divider == 0.0:

  179.                 return

  180. 

  181.             value  = current / divider

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

  183. 

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

  185. 

  186.             if self.m_orientation == self.HORIZONTAL:

  187.                 xpos = self.p_size * per

  188.                 ypos = 0.0

  189.             else:

  190.                 xpos = 0.0

  191.                 ypos = self.p_size * per

  192. 

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

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

  195. 

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

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

  198.                 # knob color

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

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

  201. 

  202.                 # draw small circle

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

  204.                 ballPath = QPainterPath()

  205.                 ballPath.addEllipse(ballRect)

  206.                 #painter.drawRect(ballRect)

  207.                 tmpValue  = (0.375 + 0.75*value)

  208.                 ballValue = tmpValue - floor(tmpValue)

  209.                 ballPoint = ballPath.pointAtPercent(ballValue)

  210. 

  211.                 # draw arc

  212.                 startAngle = 216*16

  213.                 spanAngle  = -252*16*value

  214. 

  215.                 if self.m_customPaint == self.CUSTOM_PAINT_CARLA_WET:

  216.                     painter.setBrush(colorBlue)

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

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

  219. 

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

  221.                     gradient.setColorAt(0.0,   colorBlue)

  222.                     gradient.setColorAt(0.125, colorBlue)

  223.                     gradient.setColorAt(0.625, colorGreen)

  224.                     gradient.setColorAt(0.75,  colorGreen)

  225.                     gradient.setColorAt(0.76,  colorGreen)

  226.                     gradient.setColorAt(1.0,   colorGreen)

  227.                     painter.setBrush(gradient)

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

  229. 

  230.                 else:

  231.                     painter.setBrush(colorBlue)

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

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

  234. 

  235.                     painter.setBrush(colorBlue)

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

  237. 

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

  239. 

  240.             # Custom knobs (L and R)

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

  242.                 # knob color

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

  244. 

  245.                 # draw small circle

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

  247.                 ballPath = QPainterPath()

  248.                 ballPath.addEllipse(ballRect)

  249.                 #painter.drawRect(ballRect)

  250.                 tmpValue  = (0.375 + 0.75*value)

  251.                 ballValue = tmpValue - floor(tmpValue)

  252.                 ballPoint = ballPath.pointAtPercent(ballValue)

  253. 

  254.                 painter.setBrush(color)

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

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

  257. 

  258.                 # draw arc

  259.                 if self.m_customPaint == self.CUSTOM_PAINT_CARLA_L:

  260.                     startAngle = 216*16

  261.                     spanAngle  = -252.0*16*value

  262.                 elif self.m_customPaint == self.CUSTOM_PAINT_CARLA_R:

  263.                     startAngle = 324.0*16

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

  265.                 else:

  266.                     return

  267. 

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

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

  270. 

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

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

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

  274. 

  275.         else:

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

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

  278. 

  279.         event.accept()

  280. 

  281.     def resizeEvent(self, event):

  282.         self.updateSizes()

  283.         QDial.resizeEvent(self, event)