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

Continue rework

tags/1.9.6
falkTX 9 years ago
parent
e48c8f753b
commit
780a5c54fa
4 changed files with 426 additions and 379 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +56
    -36
      source/widgets/Makefile
  2. +2
    -272
      source/widgets/digitalpeakmeter.cpp
  3. +321
    -28
      source/widgets/digitalpeakmeter.hpp
  4. +47
    -43
      source/widgets/digitalpeakmeter.py

+ 56
- 36
source/widgets/Makefile View File

@@ -1,14 +1,27 @@
#!/usr/bin/make -f
# Makefile for widgets #
# -------------------- #
# Makefile for carla-widgets #
# -------------------------- #
# Created by falkTX
#

include ../../Makefile.mk
CWD=..
include $(CWD)/Makefile.mk

# --------------------------------------------------------------
# ----------------------------------------------------------------------------------------------------------------------------

BUILD_CXX_FLAGS += -I. -I.. -I../../includes -I../../utils
BINDIR := $(CWD)/../bin

ifeq ($(DEBUG),true)
OBJDIR := $(CWD)/../build/widgets/Debug
MODULEDIR := $(CWD)/../build/modules/Debug
else
OBJDIR := $(CWD)/../build/widgets/Release
MODULEDIR := $(CWD)/../build/modules/Release
endif

# ----------------------------------------------------------------------------------------------------------------------------

BUILD_CXX_FLAGS += -I. -I$(CWD)/includes -I$(CWD)/modules -I$(CWD)/utils

ifeq ($(HAVE_QT4),true)
BUILD_CXX_FLAGS += $(shell pkg-config --cflags QtCore QtGui)
@@ -18,50 +31,57 @@ BUILD_CXX_FLAGS += $(shell pkg-config --cflags Qt5Core Qt5Gui Qt5Widgets)
LINK_FLAGS += $(shell pkg-config --libs Qt5Core Qt5Gui Qt5Widgets)
endif

# --------------------------------------------------------------
# ----------------------------------------------------------------------------------------------------------------------------

FILES = \
moc_paramspinbox.cpp \
moc_pixmapkeyboard.cpp
# FILES = \
# moc_paramspinbox.cpp \
# moc_pixmapkeyboard.cpp

OBJS = \
digitalpeakmeter.cpp.o \
ledbutton.cpp.o \
paramspinbox.cpp.o \
pixmapdial.cpp.o \
pixmapkeyboard.cpp.o
$(OBJDIR)/digitalpeakmeter.cpp.o

OBJS += \
moc_paramspinbox.cpp.o \
moc_pixmapkeyboard.cpp.o
# ledbutton.cpp.o \
# paramspinbox.cpp.o \
# pixmapdial.cpp.o \
# pixmapkeyboard.cpp.o

# --------------------------------------------------------------
# OBJS += \
# moc_paramspinbox.cpp.o \
# moc_pixmapkeyboard.cpp.o

all: ../widgets.a
TARGET = $(MODULEDIR)/widgets.a

# --------------------------------------------------------------
# ----------------------------------------------------------------------------------------------------------------------------

../widgets.a: $(FILES) $(OBJS)
$(RM) $@
$(AR) crs $@ $(OBJS)
all: $(TARGET)

# --------------------------------------------------------------
# ----------------------------------------------------------------------------------------------------------------------------

%.cpp.o: %.cpp %.hpp
$(CXX) $< $(BUILD_CXX_FLAGS) -c -o $@
clean:
rm -f $(OBJDIR)/*.o $(TARGET)

debug:
$(MAKE) DEBUG=true

moc_%.cpp.o: %.cpp
$(CXX) moc_$< $(BUILD_CXX_FLAGS) -c -o $@
# ----------------------------------------------------------------------------------------------------------------------------

moc_%.cpp: %.hpp
$(MOC) $< -o $@
$(MODULEDIR)/widgets.a: $(FILES) $(OBJS)
$(RM) $@
$(AR) crs $@ $(OBJS)

# --------------------------------------------------------------
# ----------------------------------------------------------------------------------------------------------------------------

clean:
$(RM) *.o ../widgets*.a $(FILES)
$(OBJDIR)/%.cpp.o: %.cpp
-@mkdir -p $(OBJDIR)
@echo "Compiling $<"
$(CXX) $< $(BUILD_CXX_FLAGS) -c -o $@

debug:
$(MAKE) DEBUG=true
-include $(OBJS:%.o=%.d)

# moc_%.cpp.o: %.cpp
# $(CXX) moc_$< $(BUILD_CXX_FLAGS) -c -o $@
#
# moc_%.cpp: %.hpp
# $(MOC) $< -o $@

# --------------------------------------------------------------
# ----------------------------------------------------------------------------------------------------------------------------

+ 2
- 272
source/widgets/digitalpeakmeter.cpp View File

@@ -1,6 +1,6 @@
/*
* Digital Peak Meter, a custom Qt4 widget
* Copyright (C) 2011-2013 Filipe Coelho <falktx@falktx.com>
* Digital Peak Meter, a custom Qt widget
* Copyright (C) 2011-2015 Filipe Coelho <falktx@falktx.com>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
@@ -16,273 +16,3 @@
*/

#include "digitalpeakmeter.hpp"

#include <QtGui/QPainter>
#include <QtGui/QPaintEvent>

DigitalPeakMeter::DigitalPeakMeter(QWidget* parent)
: QWidget(parent),
fChannels(0),
fSmoothMultiplier(1),
fWidth(0),
fHeight(0),
fSizeMeter(0),
fOrientation(VERTICAL),
fColorBackground("#111111"),
fGradientMeter(0, 0, 1, 1),
fColorBase(93, 231, 61),
fColorBaseAlt(15, 110, 15, 100),
fChannelsData(nullptr),
fLastValueData(nullptr)
{
setChannels(0);
setColor(GREEN);
}

DigitalPeakMeter::~DigitalPeakMeter()
{
if (fChannelsData != nullptr)
delete[] fChannelsData;
if (fLastValueData != nullptr)
delete[] fLastValueData;
}

void DigitalPeakMeter::displayMeter(int meter, float level)
{
Q_ASSERT(fChannelsData != nullptr);
Q_ASSERT(meter > 0 && meter <= fChannels);

if (meter <= 0 || meter > fChannels || fChannelsData == nullptr)
return qCritical("DigitalPeakMeter::displayMeter(%i, %f) - invalid meter number", meter, level);

int i = meter - 1;

if (fSmoothMultiplier > 0)
level = (fLastValueData[i] * fSmoothMultiplier + level) / float(fSmoothMultiplier + 1);

if (level < 0.001f)
level = 0.0f;
else if (level > 0.999f)
level = 1.0f;

if (fChannelsData[i] != level)
{
fChannelsData[i] = level;
update();
}

fLastValueData[i] = level;
}

void DigitalPeakMeter::setChannels(int channels)
{
Q_ASSERT(channels >= 0);

if (channels < 0)
return qCritical("DigitalPeakMeter::setChannels(%i) - 'channels' must be a positive integer", channels);

fChannels = channels;

if (fChannelsData != nullptr)
delete[] fChannelsData;
if (fLastValueData != nullptr)
delete[] fLastValueData;

if (channels > 0)
{
fChannelsData = new float[channels];
fLastValueData = new float[channels];

for (int i=0; i < channels; ++i)
{
fChannelsData[i] = 0.0f;
fLastValueData[i] = 0.0f;
}
}
else
{
fChannelsData = nullptr;
fLastValueData = nullptr;
}
}

void DigitalPeakMeter::setColor(Color color)
{
if (color == GREEN)
{
fColorBase = QColor(93, 231, 61);
fColorBaseAlt = QColor(15, 110, 15, 100);
}
else if (color == BLUE)
{
fColorBase = QColor(82, 238, 248);
fColorBaseAlt = QColor(15, 15, 110, 100);
}
else
return qCritical("DigitalPeakMeter::setColor(%i) - invalid color", color);

setOrientation(fOrientation);
}

void DigitalPeakMeter::setOrientation(Orientation orientation)
{
fOrientation = orientation;

if (fOrientation == HORIZONTAL)
{
fGradientMeter.setColorAt(0.0f, fColorBase);
fGradientMeter.setColorAt(0.2f, fColorBase);
fGradientMeter.setColorAt(0.4f, fColorBase);
fGradientMeter.setColorAt(0.6f, fColorBase);
fGradientMeter.setColorAt(0.8f, Qt::yellow);
fGradientMeter.setColorAt(1.0f, Qt::red);
}
else if (fOrientation == VERTICAL)
{
fGradientMeter.setColorAt(0.0f, Qt::red);
fGradientMeter.setColorAt(0.2f, Qt::yellow);
fGradientMeter.setColorAt(0.4f, fColorBase);
fGradientMeter.setColorAt(0.6f, fColorBase);
fGradientMeter.setColorAt(0.8f, fColorBase);
fGradientMeter.setColorAt(1.0f, fColorBase);
}
else
return qCritical("DigitalPeakMeter::setOrientation(%i) - invalid orientation", orientation);

updateSizes();
}

void DigitalPeakMeter::setSmoothRelease(int value)
{
Q_ASSERT(value >= 0 && value <= 5);

if (value < 0)
value = 0;
else if (value > 5)
value = 5;

fSmoothMultiplier = value;
}

QSize DigitalPeakMeter::minimumSizeHint() const
{
return QSize(10, 10);
}

QSize DigitalPeakMeter::sizeHint() const
{
return QSize(fWidth, fHeight);
}

void DigitalPeakMeter::updateSizes()
{
fWidth = width();
fHeight = height();
fSizeMeter = 0;

if (fOrientation == HORIZONTAL)
{
fGradientMeter.setFinalStop(fWidth, 0);

if (fChannels > 0)
fSizeMeter = fHeight/fChannels;
}
else if (fOrientation == VERTICAL)
{
fGradientMeter.setFinalStop(0, fHeight);

if (fChannels > 0)
fSizeMeter = fWidth/fChannels;
}
}

void DigitalPeakMeter::paintEvent(QPaintEvent* event)
{
QPainter painter(this);
event->accept();

painter.setPen(Qt::black);
painter.setBrush(Qt::black);
painter.drawRect(0, 0, fWidth, fHeight);

int meterX = 0;
painter.setPen(fColorBackground);
painter.setBrush(fGradientMeter);

for (int i=0; i < fChannels; ++i)
{
float value, level = fChannelsData[i];

if (fOrientation == HORIZONTAL)
value = level * float(fWidth);
else if (fOrientation == VERTICAL)
value = float(fHeight) - (level * float(fHeight));
else
value = 0.0f;

if (fOrientation == HORIZONTAL)
painter.drawRect(0, meterX, int(value), fSizeMeter);
else if (fOrientation == VERTICAL)
painter.drawRect(meterX, int(value), fSizeMeter, fHeight);

meterX += fSizeMeter;
}

painter.setBrush(Qt::black);

if (fOrientation == HORIZONTAL)
{
// Variables
float lsmall = fWidth;
float lfull = fHeight - 1;

// Base
painter.setPen(fColorBaseAlt);
painter.drawLine(lsmall * 0.25f, 2, lsmall * 0.25f, lfull-2.0f);
painter.drawLine(lsmall * 0.50f, 2, lsmall * 0.50f, lfull-2.0f);

// Yellow
painter.setPen(QColor(110, 110, 15, 100));
painter.drawLine(lsmall * 0.70f, 2, lsmall * 0.70f, lfull-2.0f);
painter.drawLine(lsmall * 0.83f, 2, lsmall * 0.83f, lfull-2.0f);

// Orange
painter.setPen(QColor(180, 110, 15, 100));
painter.drawLine(lsmall * 0.90f, 2, lsmall * 0.90f, lfull-2.0f);

// Red
painter.setPen(QColor(110, 15, 15, 100));
painter.drawLine(lsmall * 0.96f, 2, lsmall * 0.96f, lfull-2.0f);

}
else if (fOrientation == VERTICAL)
{
// Variables
float lsmall = fHeight;
float lfull = fWidth - 1;

// Base
painter.setPen(fColorBaseAlt);
painter.drawLine(2, lsmall - (lsmall * 0.25f), lfull-2.0f, lsmall - (lsmall * 0.25f));
painter.drawLine(2, lsmall - (lsmall * 0.50f), lfull-2.0f, lsmall - (lsmall * 0.50f));

// Yellow
painter.setPen(QColor(110, 110, 15, 100));
painter.drawLine(2, lsmall - (lsmall * 0.70f), lfull-2.0f, lsmall - (lsmall * 0.70f));
painter.drawLine(2, lsmall - (lsmall * 0.83f), lfull-2.0f, lsmall - (lsmall * 0.83f));

// Orange
painter.setPen(QColor(180, 110, 15, 100));
painter.drawLine(2, lsmall - (lsmall * 0.90f), lfull-2.0f, lsmall - (lsmall * 0.90f));

// Red
painter.setPen(QColor(110, 15, 15, 100));
painter.drawLine(2, lsmall - (lsmall * 0.96f), lfull-2.0f, lsmall - (lsmall * 0.96f));
}
}

void DigitalPeakMeter::resizeEvent(QResizeEvent* event)
{
updateSizes();
QWidget::resizeEvent(event);
}

+ 321
- 28
source/widgets/digitalpeakmeter.hpp View File

@@ -1,6 +1,6 @@
/*
* Digital Peak Meter, a custom Qt4 widget
* Copyright (C) 2011-2013 Filipe Coelho <falktx@falktx.com>
* Digital Peak Meter, a custom Qt widget
* Copyright (C) 2011-2015 Filipe Coelho <falktx@falktx.com>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
@@ -20,7 +20,8 @@

#include "CarlaJuceUtils.hpp"

#include <QtCore/QTimer>
#include <QtGui/QPainter>
#include <QtGui/QPaintEvent>

#if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
# include <QtWidgets/QWidget>
@@ -28,53 +29,345 @@
# include <QtGui/QWidget>
#endif

// ------------------------------------------------------------------------------------------------------------

class DigitalPeakMeter : public QWidget
{
public:
enum Color {
COLOR_GREEN = 1,
COLOR_BLUE = 2
};

enum Orientation {
HORIZONTAL = 1,
VERTICAL = 2
};

enum Color {
GREEN = 1,
BLUE = 2
enum Style {
STYLE_DEFAULT = 1,
STYLE_OPENAV = 2,
STYLE_RNCBC = 3
};

DigitalPeakMeter(QWidget* parent);
~DigitalPeakMeter() override;
// --------------------------------------------------------------------------------------------------------

DigitalPeakMeter(QWidget* const p)
: QWidget(p),
fChannelCount(0),
fChannelData(nullptr),
fLastChannelData(nullptr),
fMeterColor(COLOR_GREEN),
fMeterColorBase(93, 231, 61),
fMeterColorBaseAlt(15, 110, 15, 100),
fMeterLinesEnabled(true),
fMeterOrientation(VERTICAL),
fMeterStyle(STYLE_DEFAULT),
fMeterBackground("#111111"),
fMeterGradient(0, 0, 0, 0),
fSmoothMultiplier(1),
leakDetector_DigitalPeakMeter()
{
updateGrandient();
}

~DigitalPeakMeter() override
{
if (fChannelData != nullptr)
{
delete[] fChannelData;
fChannelData = nullptr;
}

if (fLastChannelData != nullptr)
{
delete[] fLastChannelData;
fLastChannelData = nullptr;
}
}

// --------------------------------------------------------------------------------------------------------

int channelCount() const noexcept
{
return fChannelCount;
}

void setChannelCount(const int count)
{
if (fChannelCount == count)
return;

if (count < 0)
return qCritical("DigitalPeakMeter::setChannelCount(%i) - channel count must be a positive integer or zero", count);

fChannelCount = count;
fChannelData = new float[count];
fLastChannelData = new float[count];

for (int i=count; --i >= 0;)
{
/**/fChannelData[i] = 0.0f;
fLastChannelData[i] = 0.0f;
}
}

// --------------------------------------------------------------------------------------------------------

Color meterColor() const noexcept
{
return fMeterColor;
}

void setMeterColor(const Color color)
{
if (fMeterColor == color)
return;

if (! QList<Color>({COLOR_GREEN, COLOR_BLUE}).contains(color))
return qCritical("DigitalPeakMeter::setMeterColor(%i) - invalid color", color);

switch (color)
{
case COLOR_GREEN:
fMeterColorBase = QColor(93, 231, 61);
fMeterColorBaseAlt = QColor(15, 110, 15, 100);
break;
case COLOR_BLUE:
fMeterColorBase = QColor(82, 238, 248);
fMeterColorBaseAlt = QColor(15, 15, 110, 100);
break;
}

fMeterColor = color;

updateGrandient();
}

// --------------------------------------------------------------------------------------------------------

bool meterLinesEnabled() const noexcept
{
return fMeterLinesEnabled;
}

void setMeterLinesEnabled(const bool yesNo)
{
if (fMeterLinesEnabled == yesNo)
return;

fMeterLinesEnabled = yesNo;
}

// --------------------------------------------------------------------------------------------------------

Orientation meterOrientation() const noexcept
{
return fMeterOrientation;
}

void setMeterOrientation(const Orientation orientation)
{
if (fMeterOrientation == orientation)
return;

if (! QList<Orientation>({HORIZONTAL, VERTICAL}).contains(orientation))
return qCritical("DigitalPeakMeter::setMeterOrientation(%i) - invalid orientation", orientation);

fMeterOrientation = orientation;

updateGrandient();
}

// --------------------------------------------------------------------------------------------------------

Style meterStyle() const noexcept
{
return fMeterStyle;
}

void displayMeter(int meter, float level);
void setChannels(int channels);
void setColor(Color color);
void setOrientation(Orientation orientation);
void setSmoothRelease(int value);
void setMeterStyle(const Style style)
{
if (fMeterStyle == style)
return;

QSize minimumSizeHint() const override;
QSize sizeHint() const override;
if (! QList<Style>({STYLE_DEFAULT, STYLE_OPENAV, STYLE_RNCBC}).contains(style))
return qCritical("DigitalPeakMeter::setMeterStyle(%i) - invalid style", style);

switch (style)
{
case STYLE_DEFAULT:
fMeterBackground = QColor("#111111");
break;
case STYLE_OPENAV:
fMeterBackground = QColor("#1A1A1A");
break;
case STYLE_RNCBC:
fMeterBackground = QColor("#111111");
break;
}

fMeterStyle = style;

updateGrandient();
}

// --------------------------------------------------------------------------------------------------------

int smoothMultiplier() const noexcept
{
return fSmoothMultiplier;
}

void setSmoothMultiplier(const int value)
{
if (fSmoothMultiplier == value)
return;

if (value < 0)
return qCritical("DigitalPeakMeter::setSmoothMultiplier(%i) - value must be >= 0", value);
if (value > 5)
return qCritical("DigitalPeakMeter::setSmoothMultiplier(%i) - value must be < 5", value);

fSmoothMultiplier = value;
}

// --------------------------------------------------------------------------------------------------------

void displayMeter(const int meter, float level, bool forced = false)
{
if (meter <= 0 or meter > fChannelCount)
return qCritical("DigitalPeakMeter::displayMeter(%i, %f) - invalid meter number", meter, level);

const int i = meter - 1;

if (fSmoothMultiplier > 0 && ! forced)
level = (fLastChannelData[i] * float(fSmoothMultiplier) + level) / float(fSmoothMultiplier + 1);

if (level < 0.001f)
level = 0.0f;
else if (level > 0.999f)
level = 1.0f;

if (fChannelData[i] != level)
{
fChannelData[i] = level;
update();
}

fLastChannelData[i] = level;
}

// --------------------------------------------------------------------------------------------------------

protected:
void updateSizes();
void updateGrandient()
{
fMeterGradient = QLinearGradient(0, 0, 1, 1);

void paintEvent(QPaintEvent* event) override;
void resizeEvent(QResizeEvent* event) override;
if (fMeterStyle == STYLE_OPENAV)
{
fMeterGradient.setColorAt(0.0, fMeterColorBase);
fMeterGradient.setColorAt(1.0, fMeterColorBase);
}
else
{
switch (fMeterOrientation)
{
case HORIZONTAL:
fMeterGradient.setColorAt(0.0, fMeterColorBase);
fMeterGradient.setColorAt(0.2, fMeterColorBase);
fMeterGradient.setColorAt(0.4, fMeterColorBase);
fMeterGradient.setColorAt(0.6, fMeterColorBase);
fMeterGradient.setColorAt(0.8, Qt::yellow);
fMeterGradient.setColorAt(1.0, Qt::red);
break;
case VERTICAL:
fMeterGradient.setColorAt(0.0, Qt::red);
fMeterGradient.setColorAt(0.2, Qt::yellow);
fMeterGradient.setColorAt(0.4, fMeterColorBase);
fMeterGradient.setColorAt(0.6, fMeterColorBase);
fMeterGradient.setColorAt(0.8, fMeterColorBase);
fMeterGradient.setColorAt(1.0, fMeterColorBase);
break;
}
}

updateGrandientFinalStop();
}

void updateGrandientFinalStop()
{
switch (fMeterOrientation)
{
case HORIZONTAL:
fMeterGradient.setFinalStop(width(), 0);
break;
case VERTICAL:
fMeterGradient.setFinalStop(0, height());
break;
}
}

// --------------------------------------------------------------------------------------------------------

QSize minimumSizeHint() const override
{
return QSize(10, 10);
}

QSize sizeHint() const override
{
return QSize(width(), height());
}

// --------------------------------------------------------------------------------------------------------

void paintEvent(QPaintEvent* const ev) override
{
QPainter painter(this);
ev->accept();

const int width_ = width();
const int height_ = height();

// draw background
painter.setPen(QPen(fMeterBackground, 2));
painter.setBrush(fMeterBackground);
painter.drawRect(0, 0, width_, height_);
}

// --------------------------------------------------------------------------------------------------------

void resizeEvent(QResizeEvent* const ev) override
{
QWidget::resizeEvent(ev);
updateGrandientFinalStop();
}

// --------------------------------------------------------------------------------------------------------

private:
int fChannels;
int fSmoothMultiplier;
int fWidth, fHeight, fSizeMeter;
Orientation fOrientation;
int fChannelCount;
float* fChannelData;
float* fLastChannelData;

Color fMeterColor;
QColor fMeterColorBase;
QColor fMeterColorBaseAlt;

QColor fColorBackground;
QLinearGradient fGradientMeter;
bool fMeterLinesEnabled;
Orientation fMeterOrientation;
Style fMeterStyle;

QColor fColorBase;
QColor fColorBaseAlt;
QColor fMeterBackground;
QLinearGradient fMeterGradient;

float* fChannelsData;
float* fLastValueData;
int fSmoothMultiplier;

CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(DigitalPeakMeter)
};

// ------------------------------------------------------------------------------------------------------------

#endif // DIGITALPEAKMETER_HPP_INCLUDED

+ 47
- 43
source/widgets/digitalpeakmeter.py View File

@@ -26,11 +26,11 @@ from carla_config import *

if config_UseQt5:
from PyQt5.QtCore import qCritical, Qt, QTimer, QSize
from PyQt5.QtGui import QColor, QLinearGradient, QPainter
from PyQt5.QtGui import QColor, QLinearGradient, QPainter, QPen
from PyQt5.QtWidgets import QWidget
else:
from PyQt4.QtCore import qCritical, Qt, QTimer, QSize
from PyQt4.QtGui import QColor, QLinearGradient, QPainter, QWidget
from PyQt4.QtGui import QColor, QLinearGradient, QPainter, QPen, QWidget

# ------------------------------------------------------------------------------------------------------------
# Widget Class
@@ -49,6 +49,8 @@ class DigitalPeakMeter(QWidget):
STYLE_OPENAV = 2
STYLE_RNCBC = 3

# --------------------------------------------------------------------------------------------------------

def __init__(self, parent):
QWidget.__init__(self, parent)

@@ -105,8 +107,6 @@ class DigitalPeakMeter(QWidget):
if color not in (self.COLOR_GREEN, self.COLOR_BLUE):
return qCritical("DigitalPeakMeter::setMeterColor(%i) - invalid color" % color)

self.fMeterColor = color

if color == self.COLOR_GREEN:
self.fMeterColorBase = QColor(93, 231, 61)
self.fMeterColorBaseAlt = QColor(15, 110, 15, 100)
@@ -114,6 +114,8 @@ class DigitalPeakMeter(QWidget):
self.fMeterColorBase = QColor(82, 238, 248)
self.fMeterColorBaseAlt = QColor(15, 15, 110, 100)

self.fMeterColor = color

self.updateGrandient()

# --------------------------------------------------------------------------------------------------------
@@ -155,8 +157,6 @@ class DigitalPeakMeter(QWidget):
if style not in (self.STYLE_DEFAULT, self.STYLE_OPENAV, self.STYLE_RNCBC):
return qCritical("DigitalPeakMeter::setMeterStyle(%i) - invalid style" % style)

self.fMeterStyle = style

if style == self.STYLE_DEFAULT:
self.fMeterBackground = QColor("#111111")
elif style == self.STYLE_OPENAV:
@@ -164,6 +164,8 @@ class DigitalPeakMeter(QWidget):
elif style == self.STYLE_RNCBC:
self.fMeterBackground = QColor("#111111")

self.fMeterStyle = style

self.updateGrandient()

# --------------------------------------------------------------------------------------------------------
@@ -219,21 +221,22 @@ class DigitalPeakMeter(QWidget):
self.fMeterGradient.setColorAt(0.0, self.fMeterColorBase)
self.fMeterGradient.setColorAt(1.0, self.fMeterColorBase)

elif self.fMeterOrientation == self.HORIZONTAL:
self.fMeterGradient.setColorAt(0.0, self.fMeterColorBase)
self.fMeterGradient.setColorAt(0.2, self.fMeterColorBase)
self.fMeterGradient.setColorAt(0.4, self.fMeterColorBase)
self.fMeterGradient.setColorAt(0.6, self.fMeterColorBase)
self.fMeterGradient.setColorAt(0.8, Qt.yellow)
self.fMeterGradient.setColorAt(1.0, Qt.red)
else:
if self.fMeterOrientation == self.HORIZONTAL:
self.fMeterGradient.setColorAt(0.0, self.fMeterColorBase)
self.fMeterGradient.setColorAt(0.2, self.fMeterColorBase)
self.fMeterGradient.setColorAt(0.4, self.fMeterColorBase)
self.fMeterGradient.setColorAt(0.6, self.fMeterColorBase)
self.fMeterGradient.setColorAt(0.8, Qt.yellow)
self.fMeterGradient.setColorAt(1.0, Qt.red)

elif self.fMeterOrientation == self.VERTICAL:
self.fMeterGradient.setColorAt(0.0, Qt.red)
self.fMeterGradient.setColorAt(0.2, Qt.yellow)
self.fMeterGradient.setColorAt(0.4, self.fMeterColorBase)
self.fMeterGradient.setColorAt(0.6, self.fMeterColorBase)
self.fMeterGradient.setColorAt(0.8, self.fMeterColorBase)
self.fMeterGradient.setColorAt(1.0, self.fMeterColorBase)
elif self.fMeterOrientation == self.VERTICAL:
self.fMeterGradient.setColorAt(0.0, Qt.red)
self.fMeterGradient.setColorAt(0.2, Qt.yellow)
self.fMeterGradient.setColorAt(0.4, self.fMeterColorBase)
self.fMeterGradient.setColorAt(0.6, self.fMeterColorBase)
self.fMeterGradient.setColorAt(0.8, self.fMeterColorBase)
self.fMeterGradient.setColorAt(1.0, self.fMeterColorBase)

self.updateGrandientFinalStop()

@@ -261,20 +264,19 @@ class DigitalPeakMeter(QWidget):
width = self.width()
height = self.height()

if self.fMeterStyle == self.STYLE_OPENAV:
painter.setPen(QColor("#1A1A1A"))
painter.setBrush(QColor("#1A1A1A"))
else:
painter.setPen(Qt.black)
painter.setBrush(Qt.black)

# draw background
painter.setPen(QPen(self.fMeterBackground, 2))
painter.setBrush(self.fMeterBackground)
painter.drawRect(0, 0, width, height)
return

meterX = 0
startX = -1 if self.fMeterStyle == self.STYLE_OPENAV else 0
padding = 2 if self.fMeterStyle == self.STYLE_OPENAV else 0
startX = 0
padding = 0
#startX = -1 if self.fMeterStyle == self.STYLE_OPENAV else 0
#padding = 2 if self.fMeterStyle == self.STYLE_OPENAV else 0

painter.setPen(self.fMeterBackground) # FIXME ?
painter.setPen(QPen(self.fMeterBackground, 0))
painter.setBrush(self.fMeterGradient)

#if self.fMeterStyle == self.STYLE_OPENAV:
@@ -285,7 +287,7 @@ class DigitalPeakMeter(QWidget):
#del color

for i in range(self.fChannelCount):
level = self.fChannelsData[i]
level = self.fChannelData[i]

if self.fMeterOrientation == self.HORIZONTAL:
value = level * float(width)
@@ -299,17 +301,17 @@ class DigitalPeakMeter(QWidget):
elif self.fMeterOrientation == self.VERTICAL:
painter.drawRect(meterX, int(value), self.fSizeMeter, self.fHeight)

meterX += self.fSizeMeter
meterX += self.fMeterSize

if not self.fDrawLines:
if not self.fMeterLinesEnabled:
return

painter.setBrush(Qt.black)

if self.fOrientation == self.HORIZONTAL:
if self.fMeterOrientation == self.HORIZONTAL:
# Variables
lsmall = float(self.fWidth)
lfull = float(self.fHeight - 1)
lsmall = float(width)
lfull = float(height - 1)

if self.fMeterStyle == self.STYLE_OPENAV:
painter.setPen(QColor(37, 37, 37, 100))
@@ -317,12 +319,12 @@ class DigitalPeakMeter(QWidget):
painter.drawLine(lsmall * 0.50, 2, lsmall * 0.50, lfull-2.0)
painter.drawLine(lsmall * 0.75, 2, lsmall * 0.75, lfull-2.0)

if self.fChannels > 1:
if self.fChannelCount > 1:
painter.drawLine(1, lfull/2, lsmall-1, lfull/2)

else:
# Base
painter.setPen(self.fColorBaseAlt)
painter.setPen(self.fMeterColorBaseAlt)
painter.drawLine(lsmall * 0.25, 2, lsmall * 0.25, lfull-2.0)
painter.drawLine(lsmall * 0.50, 2, lsmall * 0.50, lfull-2.0)

@@ -339,10 +341,10 @@ class DigitalPeakMeter(QWidget):
painter.setPen(QColor(110, 15, 15, 100))
painter.drawLine(lsmall * 0.96, 2, lsmall * 0.96, lfull-2.0)

elif self.fOrientation == self.VERTICAL:
elif self.fMeterOrientation == self.VERTICAL:
# Variables
lsmall = float(self.fHeight)
lfull = float(self.fWidth - 1)
lsmall = float(height)
lfull = float(width - 1)

if self.fMeterStyle == self.STYLE_OPENAV:
# TODO
@@ -350,7 +352,7 @@ class DigitalPeakMeter(QWidget):

else:
# Base
painter.setPen(self.fColorBaseAlt)
painter.setPen(self.fMeterColorBaseAlt)
painter.drawLine(2, lsmall - (lsmall * 0.25), lfull-2.0, lsmall - (lsmall * 0.25))
painter.drawLine(2, lsmall - (lsmall * 0.50), lfull-2.0, lsmall - (lsmall * 0.50))

@@ -370,8 +372,8 @@ class DigitalPeakMeter(QWidget):
# --------------------------------------------------------------------------------------------------------

def resizeEvent(self, event):
self.updateGrandientFinalStop()
QWidget.resizeEvent(self, event)
self.updateGrandientFinalStop()

# ------------------------------------------------------------------------------------------------------------
# Main Testing
@@ -394,3 +396,5 @@ if __name__ == '__main__':
gui.show()

sys.exit(app.exec_())

# ------------------------------------------------------------------------------------------------------------

Write Preview
Loading…
Cancel
Save