falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Browse Source

Rework of PixmapDial class

tags/1.9.4
falkTX 10 years ago
parent
436efabeed
commit
6424b5e652
3 changed files with 232 additions and 174 deletions
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +0
    -39
      resources/ui/carla_edit.ui
  2. +28
    -13
      source/carla_widgets.py
  3. +204
    -122
      source/widgets/pixmapdial.py

+ 0
- 39
resources/ui/carla_edit.ui View File

@@ -127,12 +127,6 @@
<property name="statusTip"> <property name="statusTip">
<string>Output dry/wet (100%)</string> <string>Output dry/wet (100%)</string>
</property> </property>
<property name="maximum">
<number>1000</number>
</property>
<property name="value">
<number>1000</number>
</property>
</widget> </widget>
</item> </item>
<item> <item>
@@ -155,12 +149,6 @@
<property name="statusTip"> <property name="statusTip">
<string>Output volume (100%)</string> <string>Output volume (100%)</string>
</property> </property>
<property name="maximum">
<number>1270</number>
</property>
<property name="value">
<number>1000</number>
</property>
</widget> </widget>
</item> </item>
<item> <item>
@@ -205,15 +193,6 @@
<property name="statusTip"> <property name="statusTip">
<string>Balance Left (0%)</string> <string>Balance Left (0%)</string>
</property> </property>
<property name="minimum">
<number>-1000</number>
</property>
<property name="maximum">
<number>1000</number>
</property>
<property name="value">
<number>-1000</number>
</property>
</widget> </widget>
</item> </item>
<item> <item>
@@ -236,15 +215,6 @@
<property name="statusTip"> <property name="statusTip">
<string>Balance Right (0%)</string> <string>Balance Right (0%)</string>
</property> </property>
<property name="minimum">
<number>-1000</number>
</property>
<property name="maximum">
<number>1000</number>
</property>
<property name="value">
<number>1000</number>
</property>
</widget> </widget>
</item> </item>
</layout> </layout>
@@ -277,15 +247,6 @@
<property name="statusTip"> <property name="statusTip">
<string>Balance Right (0%)</string> <string>Balance Right (0%)</string>
</property> </property>
<property name="minimum">
<number>-1000</number>
</property>
<property name="maximum">
<number>1000</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget> </widget>
</item> </item>
</layout> </layout>


+ 28
- 13
source/carla_widgets.py View File

@@ -414,25 +414,40 @@ class PluginEdit(QDialog):
# ------------------------------------------------------------- # -------------------------------------------------------------
# Set-up GUI # Set-up GUI


self.ui.dial_drywet.setCustomPaint(self.ui.dial_drywet.CUSTOM_PAINT_CARLA_WET)
self.ui.dial_drywet.setCustomPaintMode(self.ui.dial_drywet.CUSTOM_PAINT_MODE_CARLA_WET)
self.ui.dial_drywet.setPixmap(3) self.ui.dial_drywet.setPixmap(3)
self.ui.dial_drywet.setLabel("Dry/Wet") self.ui.dial_drywet.setLabel("Dry/Wet")
self.ui.dial_drywet.setMinimum(0.0)
self.ui.dial_drywet.setMaximum(1.0)
self.ui.dial_drywet.setValue(1.0)


self.ui.dial_vol.setCustomPaint(self.ui.dial_vol.CUSTOM_PAINT_CARLA_VOL)
self.ui.dial_vol.setCustomPaintMode(self.ui.dial_vol.CUSTOM_PAINT_MODE_CARLA_VOL)
self.ui.dial_vol.setPixmap(3) self.ui.dial_vol.setPixmap(3)
self.ui.dial_vol.setLabel("Volume") self.ui.dial_vol.setLabel("Volume")
self.ui.dial_vol.setMinimum(0.0)
self.ui.dial_vol.setMaximum(1.27)
self.ui.dial_vol.setValue(1.0)


self.ui.dial_b_left.setCustomPaint(self.ui.dial_b_left.CUSTOM_PAINT_CARLA_L)
self.ui.dial_b_left.setCustomPaintMode(self.ui.dial_b_left.CUSTOM_PAINT_MODE_CARLA_L)
self.ui.dial_b_left.setPixmap(4) self.ui.dial_b_left.setPixmap(4)
self.ui.dial_b_left.setLabel("L") self.ui.dial_b_left.setLabel("L")
self.ui.dial_b_left.setMinimum(-1.0)
self.ui.dial_b_left.setMaximum(1.0)
self.ui.dial_b_left.setValue(0.0)


self.ui.dial_b_right.setCustomPaint(self.ui.dial_b_right.CUSTOM_PAINT_CARLA_R)
self.ui.dial_b_right.setCustomPaintMode(self.ui.dial_b_right.CUSTOM_PAINT_MODE_CARLA_R)
self.ui.dial_b_right.setPixmap(4) self.ui.dial_b_right.setPixmap(4)
self.ui.dial_b_right.setLabel("R") self.ui.dial_b_right.setLabel("R")
self.ui.dial_b_right.setMinimum(-1.0)
self.ui.dial_b_right.setMaximum(1.0)
self.ui.dial_b_right.setValue(0.0)


self.ui.dial_pan.setCustomPaint(self.ui.dial_b_right.CUSTOM_PAINT_CARLA_R) # FIXME
self.ui.dial_pan.setCustomPaintMode(self.ui.dial_b_right.CUSTOM_PAINT_MODE_CARLA_PAN)
self.ui.dial_pan.setPixmap(4) self.ui.dial_pan.setPixmap(4)
self.ui.dial_pan.setLabel("Pan") self.ui.dial_pan.setLabel("Pan")
self.ui.dial_pan.setMinimum(-1.0)
self.ui.dial_pan.setMaximum(1.0)
self.ui.dial_pan.setValue(0.0)


self.ui.scrollArea = PixmapKeyboardHArea(self) self.ui.scrollArea = PixmapKeyboardHArea(self)
self.layout().addWidget(self.ui.scrollArea) self.layout().addWidget(self.ui.scrollArea)
@@ -467,11 +482,11 @@ class PluginEdit(QDialog):
self.ui.ch_send_pitchbend.clicked.connect(self.slot_optionChanged) self.ui.ch_send_pitchbend.clicked.connect(self.slot_optionChanged)
self.ui.ch_send_all_sound_off.clicked.connect(self.slot_optionChanged) self.ui.ch_send_all_sound_off.clicked.connect(self.slot_optionChanged)


self.ui.dial_drywet.valueChanged.connect(self.slot_dryWetChanged)
self.ui.dial_vol.valueChanged.connect(self.slot_volumeChanged)
self.ui.dial_b_left.valueChanged.connect(self.slot_balanceLeftChanged)
self.ui.dial_b_right.valueChanged.connect(self.slot_balanceRightChanged)
self.ui.dial_pan.valueChanged.connect(self.slot_panChanged)
self.ui.dial_drywet.realValueChanged.connect(self.slot_dryWetChanged)
self.ui.dial_vol.realValueChanged.connect(self.slot_volumeChanged)
self.ui.dial_b_left.realValueChanged.connect(self.slot_balanceLeftChanged)
self.ui.dial_b_right.realValueChanged.connect(self.slot_balanceRightChanged)
self.ui.dial_pan.realValueChanged.connect(self.slot_panChanged)
self.ui.sb_ctrl_channel.valueChanged.connect(self.slot_ctrlChannelChanged) self.ui.sb_ctrl_channel.valueChanged.connect(self.slot_ctrlChannelChanged)


self.ui.dial_drywet.customContextMenuRequested.connect(self.slot_knobCustomMenu) self.ui.dial_drywet.customContextMenuRequested.connect(self.slot_knobCustomMenu)
@@ -1128,17 +1143,17 @@ class PluginEdit(QDialog):
@pyqtSlot(int) @pyqtSlot(int)
def slot_dryWetChanged(self, value): def slot_dryWetChanged(self, value):
if gCarla.host is not None: if gCarla.host is not None:
gCarla.host.set_drywet(self.fPluginId, float(value)/1000)
gCarla.host.set_drywet(self.fPluginId, value)


@pyqtSlot(int) @pyqtSlot(int)
def slot_volumeChanged(self, value): def slot_volumeChanged(self, value):
if gCarla.host is not None: if gCarla.host is not None:
gCarla.host.set_volume(self.fPluginId, float(value)/1000)
gCarla.host.set_volume(self.fPluginId, value)


@pyqtSlot(int) @pyqtSlot(int)
def slot_balanceLeftChanged(self, value): def slot_balanceLeftChanged(self, value):
if gCarla.host is not None: if gCarla.host is not None:
gCarla.host.set_balance_left(self.fPluginId, float(value)/1000)
gCarla.host.set_balance_left(self.fPluginId, value)


@pyqtSlot(int) @pyqtSlot(int)
def slot_balanceRightChanged(self, value): def slot_balanceRightChanged(self, value):


+ 204
- 122
source/widgets/pixmapdial.py View File

@@ -27,12 +27,12 @@ from carla_config import *
from math import cos, floor, pi, sin from math import cos, floor, pi, sin


if config_UseQt5: if config_UseQt5:
from PyQt5.QtCore import Qt, QPointF, QRectF, QTimer, QSize
from PyQt5.QtCore import pyqtSignal, pyqtSlot, Qt, QPointF, QRectF, QTimer, QSize
from PyQt5.QtGui import QColor, QConicalGradient, QFont, QFontMetrics from PyQt5.QtGui import QColor, QConicalGradient, QFont, QFontMetrics
from PyQt5.QtGui import QLinearGradient, QPainter, QPainterPath, QPen, QPixmap from PyQt5.QtGui import QLinearGradient, QPainter, QPainterPath, QPen, QPixmap
from PyQt5.QtWidgets import QDial from PyQt5.QtWidgets import QDial
else: else:
from PyQt4.QtCore import Qt, QPointF, QRectF, QTimer, QSize
from PyQt4.QtCore import pyqtSignal, pyqtSlot, Qt, QPointF, QRectF, QTimer, QSize
from PyQt4.QtGui import QColor, QConicalGradient, QFont, QFontMetrics from PyQt4.QtGui import QColor, QConicalGradient, QFont, QFontMetrics
from PyQt4.QtGui import QDial, QLinearGradient, QPainter, QPainterPath, QPen, QPixmap from PyQt4.QtGui import QDial, QLinearGradient, QPainter, QPainterPath, QPen, QPixmap


@@ -40,15 +40,16 @@ else:
# Widget Class # Widget Class


class PixmapDial(QDial): class PixmapDial(QDial):
# enum CustomPaint
CUSTOM_PAINT_NULL = 0
CUSTOM_PAINT_CARLA_WET = 1
CUSTOM_PAINT_CARLA_VOL = 2
CUSTOM_PAINT_CARLA_L = 3
CUSTOM_PAINT_CARLA_R = 4
CUSTOM_PAINT_COLOR = 5
CUSTOM_PAINT_ZITA = 6
CUSTOM_PAINT_NO_GRADIENT = 7
# enum CustomPaintMode
CUSTOM_PAINT_MODE_NULL = 0 # default (NOTE: only this mode has label gradient)
CUSTOM_PAINT_MODE_CARLA_WET = 1 # color blue-green gradient (reserved #3)
CUSTOM_PAINT_MODE_CARLA_VOL = 2 # color blue (reserved #3)
CUSTOM_PAINT_MODE_CARLA_L = 3 # color yellow (reserved #4)
CUSTOM_PAINT_MODE_CARLA_R = 4 # color yellow (reserved #4)
CUSTOM_PAINT_MODE_CARLA_PAN = 5 # color yellow (reserved #3)
CUSTOM_PAINT_MODE_COLOR = 6 # color, selectable (reserved #3)
CUSTOM_PAINT_MODE_ZITA = 7 # custom zita knob (reserved #6)
CUSTOM_PAINT_MODE_NO_GRADIENT = 8 # skip label gradient


# enum Orientation # enum Orientation
HORIZONTAL = 0 HORIZONTAL = 0
@@ -57,23 +58,27 @@ class PixmapDial(QDial):
HOVER_MIN = 0 HOVER_MIN = 0
HOVER_MAX = 9 HOVER_MAX = 9


# signals
realValueChanged = pyqtSignal(float)

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


self.fIndex = index
self.fPixmap = QPixmap(":/bitmaps/dial_01d.png")
self.fPixmapNum = "01"

self.fCustomColor = QColor(0, 0, 0)
self.fCustomPaint = self.CUSTOM_PAINT_NULL
self.fMinimum = 0.0
self.fMaximum = 1.0
self.fRealValue = 0.0


self.fIsHovered = False self.fIsHovered = False
self.fHoverStep = self.HOVER_MIN self.fHoverStep = self.HOVER_MIN


self.fIndex = index
self.fPixmap = QPixmap(":/bitmaps/dial_01d.png")
self.fPixmapNum = "01"

if self.fPixmap.width() > self.fPixmap.height(): if self.fPixmap.width() > self.fPixmap.height():
self.fOrientation = self.HORIZONTAL
self.fPixmapOrientation = self.HORIZONTAL
else: else:
self.fOrientation = self.VERTICAL
self.fPixmapOrientation = self.VERTICAL


self.fLabel = "" self.fLabel = ""
self.fLabelPos = QPointF(0.0, 0.0) self.fLabelPos = QPointF(0.0, 0.0)
@@ -81,113 +86,179 @@ class PixmapDial(QDial):
self.fLabelFont.setPointSize(6) self.fLabelFont.setPointSize(6)
self.fLabelWidth = 0 self.fLabelWidth = 0
self.fLabelHeight = 0 self.fLabelHeight = 0
self.fLabelGradient = QLinearGradient(0, 0, 0, 1)


if self.palette().window().color().lightness() > 100: if self.palette().window().color().lightness() > 100:
# Light background # Light background
c = self.palette().dark().color() c = self.palette().dark().color()
self.fColor1 = c
self.fColor2 = QColor(c.red(), c.green(), c.blue(), 0)
self.fColorT = [self.palette().buttonText().color(), self.palette().mid().color()]
self.fLabelGradientColor1 = c
self.fLabelGradientColor2 = QColor(c.red(), c.green(), c.blue(), 0)
self.fLabelGradientColorT = [self.palette().buttonText().color(), self.palette().mid().color()]
else: else:
# Dark background # Dark background
self.fColor1 = QColor(0, 0, 0, 255)
self.fColor2 = QColor(0, 0, 0, 0)
self.fColorT = [Qt.white, Qt.darkGray]
self.fLabelGradientColor1 = QColor(0, 0, 0, 255)
self.fLabelGradientColor2 = QColor(0, 0, 0, 0)
self.fLabelGradientColorT = [Qt.white, Qt.darkGray]

self.fLabelGradient = QLinearGradient(0, 0, 0, 1)
self.fLabelGradient.setColorAt(0.0, self.fLabelGradientColor1)
self.fLabelGradient.setColorAt(0.6, self.fLabelGradientColor1)
self.fLabelGradient.setColorAt(1.0, self.fLabelGradientColor2)

self.fLabelGradientRect = QRectF(0.0, 0.0, 0.0, 0.0)

self.fCustomPaintMode = self.CUSTOM_PAINT_MODE_NULL
self.fCustomPaintColor = QColor(0xff, 0xff, 0xff)


self.updateSizes() self.updateSizes()


# Fake internal value, 10'000 precision
QDial.setMinimum(self, 0)
QDial.setMaximum(self, 10000)
QDial.setValue(self, 0)

self.valueChanged.connect(self.slot_valueChanged)

def getIndex(self): def getIndex(self):
return self.fIndex return self.fIndex


def getSize(self):
return self.fSize
def getBaseSize(self):
return self.fPixmapBaseSize


def setCustomColor(self, color):
self.fCustomColor = color
#self.update()
def forceWhiteLabelGradientText(self):
self.fLabelGradientColor1 = QColor(0, 0, 0, 255)
self.fLabelGradientColor2 = QColor(0, 0, 0, 0)
self.fLabelGradientColorT = [Qt.white, Qt.darkGray]


def setCustomPaint(self, paint):
self.fCustomPaint = paint
self.fLabelPos.setY(self.fSize + self.fLabelHeight/2)
#self.update()
#def setMidWhiteText(self):
#self.fColor1 = QColor(0, 0, 0, 255)
#self.fColor2 = QColor(0, 0, 0, 0)
#self.fColorT = [QColor("#BBB"), Qt.darkGray]


def setEnabled(self, enabled):
if self.isEnabled() != enabled:
self.fPixmap.load(":/bitmaps/dial_%s%s.png" % (self.fPixmapNum, "" if enabled else "d"))
self.updateSizes()
self.update()
QDial.setEnabled(self, enabled)
def updateSizes(self):
self.fPixmapWidth = self.fPixmap.width()
self.fPixmapHeight = self.fPixmap.height()


def setIndex(self, index):
self.fIndex = index
if self.fPixmapWidth < 1:
self.fPixmapWidth = 1


def setLabel(self, label):
self.fLabel = label
if self.fPixmapHeight < 1:
self.fPixmapHeight = 1

if self.fPixmapOrientation == self.HORIZONTAL:
self.fPixmapBaseSize = self.fPixmapHeight
self.fPixmapLayersCount = self.fPixmapWidth / self.fPixmapHeight
else:
self.fPixmapBaseSize = self.fPixmapWidth
self.fPixmapLayersCount = self.fPixmapHeight / self.fPixmapWidth

self.setMinimumSize(self.fPixmapBaseSize, self.fPixmapBaseSize + self.fLabelHeight + 5)
self.setMaximumSize(self.fPixmapBaseSize, self.fPixmapBaseSize + self.fLabelHeight + 5)


self.fLabelWidth = QFontMetrics(self.fLabelFont).width(label)
if not self.fLabel:
self.fLabelHeight = 0
self.fLabelWidth = 0
return

self.fLabelWidth = QFontMetrics(self.fLabelFont).width(self.fLabel)
self.fLabelHeight = QFontMetrics(self.fLabelFont).height() self.fLabelHeight = QFontMetrics(self.fLabelFont).height()


self.fLabelPos.setX(float(self.fSize)/2.0 - float(self.fLabelWidth)/2.0)
self.fLabelPos.setY(self.fSize + self.fLabelHeight)
self.fLabelPos.setX(float(self.fPixmapBaseSize)/2.0 - float(self.fLabelWidth)/2.0)

if self.fPixmapNum in ("01", "02"):
self.fLabelPos.setY(self.fPixmapBaseSize + self.fLabelHeight)
else:
self.fLabelPos.setY(self.fPixmapBaseSize + self.fLabelHeight/2)

self.fLabelGradient.setStart(0, float(self.fPixmapBaseSize)/2.0)
self.fLabelGradient.setFinalStop(0, self.fPixmapBaseSize + self.fLabelHeight + 5)

self.fLabelGradientRect = QRectF(float(self.fPixmapBaseSize)/8.0, float(self.fPixmapBaseSize)/2.0, float(self.fPixmapBaseSize*3)/4.0, self.fPixmapBaseSize+self.fLabelHeight+5)

def setCustomPaintMode(self, paintMode):
if self.fCustomPaintMode == paintMode:
return

self.fCustomPaintMode = paintMode
self.update()

def setCustomPaintColor(self, color):
if self.fCustomPaintColor == color:
return

self.fCustomPaintColor = color
self.update()

def setLabel(self, label):
if self.fLabel == label:
return

self.fLabel = label
self.updateSizes()
self.update()

def setEnabled(self, enabled):
if self.isEnabled() == enabled:
return


self.fLabelGradient.setColorAt(0.0, self.fColor1)
self.fLabelGradient.setColorAt(0.6, self.fColor1)
self.fLabelGradient.setColorAt(1.0, self.fColor2)
QDial.setEnabled(self, enabled)


self.fLabelGradient.setStart(0, float(self.fSize)/2.0)
self.fLabelGradient.setFinalStop(0, self.fSize + self.fLabelHeight + 5)
self.fPixmap.load(":/bitmaps/dial_%s%s.png" % (self.fPixmapNum, "" if enabled else "d"))
self.updateSizes()
self.update()


self.fLabelGradientRect = QRectF(float(self.fSize)/8.0, float(self.fSize)/2.0, float(self.fSize*6)/8.0, self.fSize+self.fLabelHeight+5)
#self.update()
def setIndex(self, index):
self.fIndex = index


def setPixmap(self, pixmapId): def setPixmap(self, pixmapId):
self.fPixmapNum = "%02i" % pixmapId self.fPixmapNum = "%02i" % pixmapId
self.fPixmap.load(":/bitmaps/dial_%s%s.png" % (self.fPixmapNum, "" if self.isEnabled() else "d")) self.fPixmap.load(":/bitmaps/dial_%s%s.png" % (self.fPixmapNum, "" if self.isEnabled() else "d"))


if self.fPixmap.width() > self.fPixmap.height(): if self.fPixmap.width() > self.fPixmap.height():
self.fOrientation = self.HORIZONTAL
self.fPixmapOrientation = self.HORIZONTAL
else: else:
self.fOrientation = self.VERTICAL
self.fPixmapOrientation = self.VERTICAL


self.updateSizes()
#self.update()
# special pixmaps
if self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_NULL:
# reserved for carla-wet, carla-vol, carla-pan and color
if self.fPixmapNum == "03":
self.fCustomPaintMode = self.CUSTOM_PAINT_MODE_COLOR


def setWhiteText(self):
self.fColor1 = QColor(0, 0, 0, 255)
self.fColor2 = QColor(0, 0, 0, 0)
self.fColorT = [Qt.white, Qt.darkGray]
# reserved for carla-L and carla-R
elif self.fPixmapNum == "04":
self.fCustomPaintMode = self.CUSTOM_PAINT_MODE_CARLA_L


def setMidWhiteText(self):
self.fColor1 = QColor(0, 0, 0, 255)
self.fColor2 = QColor(0, 0, 0, 0)
self.fColorT = [QColor("#BBB"), Qt.darkGray]
# reserved for zita
elif self.fPixmapNum == "06":
self.fCustomPaintMode = self.CUSTOM_PAINT_MODE_ZITA


def minimumSizeHint(self):
return QSize(self.fSize, self.fSize)
self.updateSizes()
self.update()


def sizeHint(self):
return QSize(self.fSize, self.fSize)
def setMinimum(self, value):
self.fMinimum = value


def updateSizes(self):
self.fWidth = self.fPixmap.width()
self.fHeight = self.fPixmap.height()
def setMaximum(self, value):
self.fMaximum = value


if self.fWidth < 1:
self.fWidth = 1
def setValue(self, value):
if self.fRealValue == value:
return


if self.fHeight < 1:
self.fHeight = 1
self.fRealValue = value
normValue = float(value - self.fMinimum) / float(self.fMaximum - self.fMinimum)
QDial.setValue(self, int(normValue * 10000))


if self.fOrientation == self.HORIZONTAL:
self.fSize = self.fHeight
self.fCount = self.fWidth / self.fHeight
else:
self.fSize = self.fWidth
self.fCount = self.fHeight / self.fWidth
@pyqtSlot(int)
def slot_valueChanged(self, value):
self.fRealValue = float(value)/10000.0 * (self.fMaximum - self.fMinimum) + self.fMinimum
self.realValueChanged.emit(self.fRealValue)


self.setMinimumSize(self.fSize, self.fSize + self.fLabelHeight + 5)
self.setMaximumSize(self.fSize, self.fSize + self.fLabelHeight + 5)
def minimumSizeHint(self):
return QSize(self.fPixmapBaseSize, self.fPixmapBaseSize)

def sizeHint(self):
return QSize(self.fPixmapBaseSize, self.fPixmapBaseSize)


def enterEvent(self, event): def enterEvent(self, event):
self.fIsHovered = True self.fIsHovered = True
@@ -209,39 +280,33 @@ class PixmapDial(QDial):
painter.setRenderHint(QPainter.Antialiasing, True) painter.setRenderHint(QPainter.Antialiasing, True)


if self.fLabel: if self.fLabel:
if self.fCustomPaint == self.CUSTOM_PAINT_NULL:
painter.setPen(self.fColor2)
if self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_NULL:
painter.setPen(self.fLabelGradientColor2)
painter.setBrush(self.fLabelGradient) painter.setBrush(self.fLabelGradient)
painter.drawRect(self.fLabelGradientRect) painter.drawRect(self.fLabelGradientRect)


painter.setFont(self.fLabelFont) painter.setFont(self.fLabelFont)
painter.setPen(self.fColorT[0 if self.isEnabled() else 1])
painter.setPen(self.fLabelGradientColorT[0 if self.isEnabled() else 1])
painter.drawText(self.fLabelPos, self.fLabel) painter.drawText(self.fLabelPos, self.fLabel)


if self.isEnabled(): if self.isEnabled():
current = float(self.value() - self.minimum())
divider = float(self.maximum() - self.minimum())

if divider == 0.0:
return
normValue = float(self.fRealValue - self.fMinimum) / float(self.fMaximum - self.fMinimum)
target = QRectF(0.0, 0.0, self.fPixmapBaseSize, self.fPixmapBaseSize)


value = current / divider
target = QRectF(0.0, 0.0, self.fSize, self.fSize)
curLayer = int((self.fPixmapLayersCount - 1) * normValue)


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

if self.fOrientation == self.HORIZONTAL:
xpos = self.fSize * per
if self.fPixmapOrientation == self.HORIZONTAL:
xpos = self.fPixmapBaseSize * curLayer
ypos = 0.0 ypos = 0.0
else: else:
xpos = 0.0 xpos = 0.0
ypos = self.fSize * per
ypos = self.fPixmapBaseSize * curLayer


source = QRectF(xpos, ypos, self.fSize, self.fSize)
source = QRectF(xpos, ypos, self.fPixmapBaseSize, self.fPixmapBaseSize)
painter.drawPixmap(target, self.fPixmap, source) painter.drawPixmap(target, self.fPixmap, source)


# Custom knobs (Dry/Wet and Volume) # Custom knobs (Dry/Wet and Volume)
if self.fCustomPaint in (self.CUSTOM_PAINT_CARLA_WET, self.CUSTOM_PAINT_CARLA_VOL):
if self.fCustomPaintMode in (self.CUSTOM_PAINT_MODE_CARLA_WET, self.CUSTOM_PAINT_MODE_CARLA_VOL):
# knob color # knob color
colorGreen = QColor(0x5D, 0xE7, 0x3D).lighter(100 + self.fHoverStep*6) colorGreen = QColor(0x5D, 0xE7, 0x3D).lighter(100 + self.fHoverStep*6)
colorBlue = QColor(0x3E, 0xB8, 0xBE).lighter(100 + self.fHoverStep*6) colorBlue = QColor(0x3E, 0xB8, 0xBE).lighter(100 + self.fHoverStep*6)
@@ -251,15 +316,15 @@ class PixmapDial(QDial):
ballPath = QPainterPath() ballPath = QPainterPath()
ballPath.addEllipse(ballRect) ballPath.addEllipse(ballRect)
#painter.drawRect(ballRect) #painter.drawRect(ballRect)
tmpValue = (0.375 + 0.75*value)
tmpValue = (0.375 + 0.75*normValue)
ballValue = tmpValue - floor(tmpValue) ballValue = tmpValue - floor(tmpValue)
ballPoint = ballPath.pointAtPercent(ballValue) ballPoint = ballPath.pointAtPercent(ballValue)


# draw arc # draw arc
startAngle = 216*16 startAngle = 216*16
spanAngle = -252*16*value
spanAngle = -252*16*normValue


if self.fCustomPaint == self.CUSTOM_PAINT_CARLA_WET:
if self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_CARLA_WET:
painter.setBrush(colorBlue) painter.setBrush(colorBlue)
painter.setPen(QPen(colorBlue, 0)) painter.setPen(QPen(colorBlue, 0))
painter.drawEllipse(QRectF(ballPoint.x(), ballPoint.y(), 2.2, 2.2)) painter.drawEllipse(QRectF(ballPoint.x(), ballPoint.y(), 2.2, 2.2))
@@ -285,7 +350,7 @@ class PixmapDial(QDial):
painter.drawArc(4.0, 4.0, 26.0, 26.0, startAngle, spanAngle) painter.drawArc(4.0, 4.0, 26.0, 26.0, startAngle, spanAngle)


# Custom knobs (L and R) # Custom knobs (L and R)
elif self.fCustomPaint in (self.CUSTOM_PAINT_CARLA_L, self.CUSTOM_PAINT_CARLA_R):
elif self.fCustomPaintMode in (self.CUSTOM_PAINT_MODE_CARLA_L, self.CUSTOM_PAINT_MODE_CARLA_R):
# knob color # knob color
color = QColor(0xAD, 0xD5, 0x48).lighter(100 + self.fHoverStep*6) color = QColor(0xAD, 0xD5, 0x48).lighter(100 + self.fHoverStep*6)


@@ -294,7 +359,7 @@ class PixmapDial(QDial):
ballPath = QPainterPath() ballPath = QPainterPath()
ballPath.addEllipse(ballRect) ballPath.addEllipse(ballRect)
#painter.drawRect(ballRect) #painter.drawRect(ballRect)
tmpValue = (0.375 + 0.75*value)
tmpValue = (0.375 + 0.75*normValue)
ballValue = tmpValue - floor(tmpValue) ballValue = tmpValue - floor(tmpValue)
ballPoint = ballPath.pointAtPercent(ballValue) ballPoint = ballPath.pointAtPercent(ballValue)


@@ -303,34 +368,32 @@ class PixmapDial(QDial):
painter.drawEllipse(QRectF(ballPoint.x(), ballPoint.y(), 2.0, 2.0)) painter.drawEllipse(QRectF(ballPoint.x(), ballPoint.y(), 2.0, 2.0))


# draw arc # draw arc
if self.fCustomPaint == self.CUSTOM_PAINT_CARLA_L:
if self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_CARLA_L:
startAngle = 216*16 startAngle = 216*16
spanAngle = -252.0*16*value
elif self.fCustomPaint == self.CUSTOM_PAINT_CARLA_R:
startAngle = 324.0*16
spanAngle = 252.0*16*(1.0-value)
spanAngle = -252.0*16*normValue
else: else:
return
startAngle = 324.0*16
spanAngle = 252.0*16*(1.0-normValue)


painter.setPen(QPen(color, 2)) painter.setPen(QPen(color, 2))
painter.drawArc(3.5, 4.5, 22.0, 22.0, startAngle, spanAngle) painter.drawArc(3.5, 4.5, 22.0, 22.0, startAngle, spanAngle)


# Custom knobs (Color) # Custom knobs (Color)
elif self.fCustomPaint == self.CUSTOM_PAINT_COLOR:
elif self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_COLOR:
# knob color # knob color
color = self.fCustomColor.lighter(100 + self.fHoverStep*6)
color = self.fCustomPaintColor.lighter(100 + self.fHoverStep*6)


# draw small circle # draw small circle
ballRect = QRectF(8.0, 8.0, 15.0, 15.0) ballRect = QRectF(8.0, 8.0, 15.0, 15.0)
ballPath = QPainterPath() ballPath = QPainterPath()
ballPath.addEllipse(ballRect) ballPath.addEllipse(ballRect)
tmpValue = (0.375 + 0.75*value)
tmpValue = (0.375 + 0.75*normValue)
ballValue = tmpValue - floor(tmpValue) ballValue = tmpValue - floor(tmpValue)
ballPoint = ballPath.pointAtPercent(ballValue) ballPoint = ballPath.pointAtPercent(ballValue)


# draw arc # draw arc
startAngle = 216*16 startAngle = 216*16
spanAngle = -252*16*value
spanAngle = -252*16*normValue


painter.setBrush(color) painter.setBrush(color)
painter.setPen(QPen(color, 0)) painter.setPen(QPen(color, 0))
@@ -341,8 +404,8 @@ class PixmapDial(QDial):
painter.drawArc(4.0, 4.0, 26.0, 26.0, startAngle, spanAngle) painter.drawArc(4.0, 4.0, 26.0, 26.0, startAngle, spanAngle)


# Custom knobs (Zita) # Custom knobs (Zita)
elif self.fCustomPaint == self.CUSTOM_PAINT_ZITA:
a = value * pi * 1.5 - 2.35
elif self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_ZITA:
a = normValue * pi * 1.5 - 2.35
r = 10.0 r = 10.0
x = 10.5 x = 10.5
y = 10.5 y = 10.5
@@ -362,11 +425,30 @@ class PixmapDial(QDial):
QTimer.singleShot(20, self.update) QTimer.singleShot(20, self.update)


else: # isEnabled() else: # isEnabled()
target = QRectF(0.0, 0.0, self.fSize, self.fSize)
target = QRectF(0.0, 0.0, self.fPixmapBaseSize, self.fPixmapBaseSize)
painter.drawPixmap(target, self.fPixmap, target) painter.drawPixmap(target, self.fPixmap, target)


painter.restore() painter.restore()


def resizeEvent(self, event): def resizeEvent(self, event):
self.updateSizes()
QDial.resizeEvent(self, event) QDial.resizeEvent(self, event)
self.updateSizes()

# ------------------------------------------------------------------------------------------------------------
# Main Testing

if __name__ == '__main__':
import sys
from PyQt4.QtGui import QApplication
import resources_rc

app = QApplication(sys.argv)

gui = PixmapDial(None)
#gui.setEnabled(True)
#gui.setEnabled(False)
gui.setPixmap(3)
gui.setLabel("hahaha")
gui.show()

sys.exit(app.exec_())

Write Preview
Loading…
Cancel
Save