Browse the code

Differences between 100 and 101 on /trunk/widget/Fader.cpp.

Number of edited files:

1 (0 added, 0 deleted and 1 modified)

Author:

livemix

Log message:

add lash support

Date:

2007-11-23 07:23:23

Added file(s)	Deleted file(s)	Modified file(s)
		/trunk/widget/Fader.cpp ↓


namespace LiveMix
{

Fader::Fader( QWidget *pParent, bool bUseIntSteps, bool bWithoutKnob, bool p_bLinDb )
        : Volume( pParent )
        , m_bWithoutKnob( bWithoutKnob )
        , m_bUseIntSteps( bUseIntSteps )
Fader::Fader(QWidget *pParent, bool bUseIntSteps, bool bWithoutKnob, bool p_bLinDb)
        : Volume(pParent)
        , m_bWithoutKnob(bWithoutKnob)
        , m_bUseIntSteps(bUseIntSteps)
        , m_bLinDb(p_bLinDb)
        , m_fPeakValue_L( -60 )
        , m_fPeakValue_R( -60 )
        , m_fMinPeak( -60 )
        , m_fMaxPeak( 20 )
        , m_fValue( 0.0 )
        , m_fMinValue( -60 )
        , m_fMaxValue( 20 )
        , m_fPeakValue_L(-60)
        , m_fPeakValue_R(-60)
        , m_fMinPeak(-60)
        , m_fMaxPeak(20)
        , m_fValue(0.0)
        , m_fMinValue(-60)
        , m_fMaxValue(20)
{
    setAttribute( Qt::WA_NoBackground );
    setMinimumSize( 23, 116 );
    setMaximumSize( 23, 116);
    resize( 23, 116 );
	
	m_fMousePressValue = m_fMinValue - 1;
    setAttribute(Qt::WA_NoBackground);
    setMinimumSize(23, 116);
    setMaximumSize(23, 116);
    resize(23, 116);

    m_fMousePressValue = m_fMinValue - 1;

    // Background image
    QString path = ":/data/fader_background.svg";
    bool ok = m_back_original.load( path );
    if( ok == false ) {
    bool ok = m_back_original.load(path);
    if (ok == false) {
        qDebug() << "Fader: Error loading pixmap: " << path;
    }

    path = ":/data/fader_top.svg";
    ok = m_top.load( path );
    if( ok == false ) {
    ok = m_top.load(path);
    if (ok == false) {
        qDebug() << "Fader: Error loading pixmap: " << path;
    }

    path = ":/data/fader_bottom.svg";
    ok = m_bottom.load( path );
    if( ok == false ) {
    ok = m_bottom.load(path);
    if (ok == false) {
        qDebug() << "Fader: Error loading pixmap: " << path;
    }

    // Leds image
    QString leds_path = ":/data/fader_leds.svg";
    ok = m_leds_original.load( leds_path );
    if( ok == false ) {
    ok = m_leds_original.load(leds_path);
    if (ok == false) {
        qDebug() << "Error loading pixmap: " << ":/data/fader_background.svg";
    }

    // Knob image
    QString knob_path = ":/data/fader_knob.png";
    ok = m_knob.load( knob_path );
    if( ok == false ) {
    ok = m_knob.load(knob_path);
    if (ok == false) {
        qDebug() << "Error loading pixmap: " << ":/data/fader_knob.png";
    }
}
{
// qDebug() << "[Destroy] Fader";
}
QWidget* Fader::getWidget() {
QWidget* Fader::getWidget()
{
    return this;
}

void Fader::setFixedHeight ( int h ) {
	QWidget::setFixedHeight(h);
void Fader::setFixedHeight(int h)
{
    QWidget::setFixedHeight(h);
    m_back_scaled = m_back_original.scaled(width(), height()-30, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
    m_leds_scaled = m_leds_original.scaled(width(), height()-30, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
}
void Fader::setFixedSize ( const QSize & s ) {
	QWidget::setFixedSize(s);
void Fader::setFixedSize(const QSize & s)
{
    QWidget::setFixedSize(s);
    m_back_scaled = m_back_original.scaled(width(), height()-30, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
    m_leds_scaled = m_leds_original.scaled(width(), height()-30, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
} 
void Fader::setFixedSize ( int w, int h ) {
	QWidget::setFixedSize(w, h);
}
void Fader::setFixedSize(int w, int h)
{
    QWidget::setFixedSize(w, h);
    m_back_scaled = m_back_original.scaled(width(), height()-30, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
    m_leds_scaled = m_leds_original.scaled(width(), height()-30, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
}

void Fader::mouseMoveEvent( QMouseEvent *ev )
void Fader::mouseMoveEvent(QMouseEvent *ev)
{
    if (m_fMousePressValue != m_fMinValue - 1) {
        float fRange = m_fMaxValue - m_fMinValue;

        float deltaY = ev->y() - m_fMousePressY;
        float fNewValue = ( m_fMousePressValue - ( deltaY / height() * fRange ) );
        float fNewValue = (m_fMousePressValue - (deltaY / height() * fRange));

        setValue( fNewValue, true );
        setValue(fNewValue, true);
    }
/*	if (ev->button() == Qt::LeftButton) {
	    float fVal = (float)( height() - ev->y() ) / (float)height();
	    fVal = fVal * ( m_fMaxValue - m_fMinValue );
	
	    fVal = fVal + m_fMinValue;
	
	    setValue( fVal, true );
	}*/
    /* if (ev->button() == Qt::LeftButton) {
         float fVal = (float)( height() - ev->y() ) / (float)height();
         fVal = fVal * ( m_fMaxValue - m_fMinValue );

         fVal = fVal + m_fMinValue;

         setValue( fVal, true );
     }*/
}


void Fader::mousePressEvent(QMouseEvent *ev)
{
	if (ev->button() == Qt::LeftButton) {
	    setCursor( QCursor( Qt::SizeVerCursor ) );
    if (ev->button() == Qt::LeftButton) {
        setCursor(QCursor(Qt::SizeVerCursor));

	    m_fMousePressValue = m_fValue;
	    m_fMousePressY = ev->y();
	}
        m_fMousePressValue = m_fValue;
        m_fMousePressY = ev->y();
    }
}

void Fader::mouseReleaseEvent(QMouseEvent* ev)
{
    if (ev->button() == Qt::LeftButton) {
	    setCursor( QCursor( Qt::ArrowCursor ) );
	    m_fMousePressValue = m_fMinValue - 1;
    	emit leftClick(ev);
        setCursor(QCursor(Qt::ArrowCursor));
        m_fMousePressValue = m_fMinValue - 1;
        emit leftClick(ev);
    } else if (ev->button() == Qt::RightButton) {
    	emit rightClick(ev);
        emit rightClick(ev);
    } else if (ev->button() == Qt::MidButton) {
    	emit middleClick(ev);
        emit middleClick(ev);
    }
}

void Fader::mouseDoubleClickEvent(QMouseEvent* ev) {
void Fader::mouseDoubleClickEvent(QMouseEvent* ev)
{
    if (ev->button() == Qt::LeftButton) {
	    float fVal = (float)( height() - ev->y() - 15.0 ) / ((float)height() - 30.0);
	    fVal = fVal * ( m_fMaxValue - m_fMinValue );
	
	    fVal = fVal + m_fMinValue;
	
	    setValue( fVal, true );
        float fVal = (float)(height() - ev->y() - 15.0) / ((float)height() - 30.0);
        fVal = fVal * (m_fMaxValue - m_fMinValue);

        fVal = fVal + m_fMinValue;

        setValue(fVal, true);
    }
}

{
    if (m_bUseIntSteps) {
        if (p_bDirection) {
            setValue( m_fValue + 1 * p_iStep, true );
            setValue(m_fValue + 1 * p_iStep, true);
        } else {
            setValue( m_fValue - 1 * p_iStep, true );
            setValue(m_fValue - 1 * p_iStep, true);
        }
    } else {
        float step = 0.5;
        if (m_fMinValue > -20) {
            step = ( m_fMaxValue - m_fMinValue ) / 50.0;
            step = (m_fMaxValue - m_fMinValue) / 50.0;
        }

        if (p_bDirection) {
            setValue( m_fValue + step * p_iStep, true );
            setValue(m_fValue + step * p_iStep, true);
        } else {
            setValue( m_fValue - step * p_iStep, true );
            setValue(m_fValue - step * p_iStep, true);
        }
    }
}

void Fader::setValue( float fVal, bool do_emit )
void Fader::setValue(float fVal, bool do_emit)
{
    if ( fVal > m_fMaxValue ) {
    if (fVal > m_fMaxValue) {
        fVal = m_fMaxValue;
    } else if ( fVal < m_fMinValue ) {
    } else if (fVal < m_fMinValue) {
        fVal = m_fMinValue;
    }

    if ( m_bUseIntSteps ) {
    if (m_bUseIntSteps) {
        fVal = (int)fVal;
    }

    if ( m_fValue != fVal ) {
    if (m_fValue != fVal) {
        m_fValue = fVal;
        update();
    }


// in fact the external value is standanrd and internal in dB
void Fader::setDbValue( float val )
void Fader::setDbValue(float val)
{
    setValue(m_bLinDb ? lin2db(val, m_fMinValue) : lin2db(val));
}
void Fader::setDbPeak_L( float peak )
void Fader::setDbPeak_L(float peak)
{
    setPeak_L(m_bLinDb ? lin2db(peak, m_fMinPeak) : lin2db(peak));
}
{
    return m_bLinDb ? db2lin(m_fPeakValue_L, m_fMinPeak) : db2lin(m_fPeakValue_L);
}
void Fader::setDbPeak_R( float peak )
void Fader::setDbPeak_R(float peak)
{
    setPeak_R(m_bLinDb ? lin2db(peak, m_fMinPeak) : lin2db(peak));
}
    return m_bLinDb ? db2lin(m_fPeakValue_R, m_fMinPeak) : db2lin(m_fPeakValue_R);
}

void Fader::setDbMaxValue( float val )
void Fader::setDbMaxValue(float val)
{
    setMaxValue(m_bLinDb ? lin2db(val, m_fMinValue) : lin2db(val));
}
void Fader::setDbMinValue( float val )
void Fader::setDbMinValue(float val)
{
    setMinValue(m_bLinDb ? lin2db(val, m_fMinValue) : lin2db(val));
}
void Fader::setDbMaxPeak( float val )
void Fader::setDbMaxPeak(float val)
{
    setMaxPeak(m_bLinDb ? lin2db(val, m_fMinValue) : lin2db(val));
}
void Fader::setDbMinPeak( float val )
void Fader::setDbMinPeak(float val)
{
    setMinPeak(m_bLinDb ? lin2db(val, m_fMinValue) : lin2db(val));
}
///
/// Set peak value (0.0 .. 1.0)
///
void Fader::setPeak_L( float fPeak )
void Fader::setPeak_L(float fPeak)
{
    if ( fPeak <  m_fMinPeak ) {
    if (fPeak <  m_fMinPeak) {
        fPeak = m_fMinPeak;
    } else if ( fPeak > m_fMaxPeak ) {
    } else if (fPeak > m_fMaxPeak) {
        fPeak = m_fMaxPeak;
    }

    if ( m_fPeakValue_L != fPeak) {
    if (m_fPeakValue_L != fPeak) {
        m_fPeakValue_L = fPeak;
        update();
    }
///
/// Set peak value (0.0 .. 1.0)
///
void Fader::setPeak_R( float fPeak )
void Fader::setPeak_R(float fPeak)
{
    if ( fPeak <  m_fMinPeak ) {
    if (fPeak <  m_fMinPeak) {
        fPeak = m_fMinPeak;
    } else if ( fPeak > m_fMaxPeak ) {
    } else if (fPeak > m_fMaxPeak) {
        fPeak = m_fMaxPeak;
    }

    if ( m_fPeakValue_R != fPeak ) {
    if (m_fPeakValue_R != fPeak) {
        m_fPeakValue_R = fPeak;
        update();
    }
    QPainter painter(this);

    // background
    painter.drawPixmap( QRect(0, 15, width(), height()-30), m_back_scaled, QRect(0, 0, width(), height()-30));
    painter.drawPixmap( QRect(0, 0, width(), 15), m_top, QRect(0, 0, width(), 15) );
    painter.drawPixmap( QRect(0, height() - 15, width(), 15), m_bottom, QRect(0, 0, width(), 15) );
    painter.drawPixmap(QRect(0, 15, width(), height()-30), m_back_scaled, QRect(0, 0, width(), height()-30));
    painter.drawPixmap(QRect(0, 0, width(), 15), m_top, QRect(0, 0, width(), 15));
    painter.drawPixmap(QRect(0, height() - 15, width(), 15), m_bottom, QRect(0, 0, width(), 15));

    // peak leds
	if (m_fMaxPeak > m_fMinPeak) {
	    float realPeak_L = m_fPeakValue_L - m_fMinPeak;
	    int peak_L = (int)(height() - 30 - ( realPeak_L / ( m_fMaxPeak - m_fMinPeak ) ) * (height() - 30));
	    if (peak_L > height() - 30) {
	        peak_L = height() - 30;
	    }
	    painter.drawPixmap( QRect( 0, peak_L + 15, width() / 2, height() - 30 - peak_L ), m_leds_scaled, 
	    					QRect( 0, peak_L     , width() / 2, height() - 30 - peak_L ) );
	
	
	    float realPeak_R = m_fPeakValue_R - m_fMinPeak;
	    int peak_R = (int)(height() - 30 - ( realPeak_R / ( m_fMaxPeak - m_fMinPeak ) ) * (height() - 30));
	    if (peak_R > height() - 30) {
	        peak_R = height() - 30;
	    }
	    painter.drawPixmap( QRect( width() / 2, peak_R + 15, width() / 2, height() - 30 - peak_R ), m_leds_scaled, 
	    					QRect( width() / 2, peak_R     , width() / 2, height() - 30 - peak_R ) );
	}
    if (m_fMaxPeak > m_fMinPeak) {
        float realPeak_L = m_fPeakValue_L - m_fMinPeak;
        int peak_L = (int)(height() - 30 - (realPeak_L / (m_fMaxPeak - m_fMinPeak)) * (height() - 30));
        if (peak_L > height() - 30) {
            peak_L = height() - 30;
        }
        painter.drawPixmap(QRect(0, peak_L + 15, width() / 2, height() - 30 - peak_L), m_leds_scaled,
                           QRect(0, peak_L     , width() / 2, height() - 30 - peak_L));


        float realPeak_R = m_fPeakValue_R - m_fMinPeak;
        int peak_R = (int)(height() - 30 - (realPeak_R / (m_fMaxPeak - m_fMinPeak)) * (height() - 30));
        if (peak_R > height() - 30) {
            peak_R = height() - 30;
        }
        painter.drawPixmap(QRect(width() / 2, peak_R + 15, width() / 2, height() - 30 - peak_R), m_leds_scaled,
                           QRect(width() / 2, peak_R     , width() / 2, height() - 30 - peak_R));
    }

    if (!m_bWithoutKnob) {
        // knob
        static const uint knob_height = 29;

        float realVal = m_fValue - m_fMinValue;

        uint knob_y = (uint)( height() - ( ( height() - 30 ) * ( realVal / fRange ) ) );
        uint knob_y = (uint)(height() - ((height() - 30) * (realVal / fRange)));

        painter.drawPixmap( QRect( 4, knob_y - knob_height, knob_width, knob_height), m_knob, QRect( 0, 0, knob_width, knob_height ) );
        painter.drawPixmap(QRect(4, knob_y - knob_height, knob_width, knob_height), m_knob, QRect(0, 0, knob_width, knob_height));
    }
}


void Fader::setMinValue( float fMin )
void Fader::setMinValue(float fMin)
{
    m_fMinValue = fMin;
	m_fMousePressValue = m_fMinValue - 1;
    m_fMousePressValue = m_fMinValue - 1;
}


void Fader::setMaxValue( float fMax )
void Fader::setMaxValue(float fMax)
{
    m_fMaxValue = fMax;
}


void Fader::setMaxPeak( float fMax )
void Fader::setMaxPeak(float fMax)
{
    m_fMaxPeak = fMax;
}


void Fader::setMinPeak( float fMin )
void Fader::setMinPeak(float fMin)
{
    m_fMinPeak = fMin;
}


Old	New	Code
33	33	namespace LiveMix
34	34	{
35	35
36		Fader::Fader( QWidget *pParent, bool bUseIntSteps, bool bWithoutKnob, bool p_bLinDb )
37		: Volume( pParent )
38		, m_bWithoutKnob( bWithoutKnob )
39		, m_bUseIntSteps( bUseIntSteps )
	36	Fader::Fader(QWidget *pParent, bool bUseIntSteps, bool bWithoutKnob, bool p_bLinDb)
	37	: Volume(pParent)
	38	, m_bWithoutKnob(bWithoutKnob)
	39	, m_bUseIntSteps(bUseIntSteps)
40	40	, m_bLinDb(p_bLinDb)
41		, m_fPeakValue_L( -60 )
42		, m_fPeakValue_R( -60 )
43		, m_fMinPeak( -60 )
44		, m_fMaxPeak( 20 )
45		, m_fValue( 0.0 )
46		, m_fMinValue( -60 )
47		, m_fMaxValue( 20 )
	41	, m_fPeakValue_L(-60)
	42	, m_fPeakValue_R(-60)
	43	, m_fMinPeak(-60)
	44	, m_fMaxPeak(20)
	45	, m_fValue(0.0)
	46	, m_fMinValue(-60)
	47	, m_fMaxValue(20)
48	48	{
49		setAttribute( Qt::WA_NoBackground );
50		setMinimumSize( 23, 116 );
51		setMaximumSize( 23, 116);
52		resize( 23, 116 );
53
54		m_fMousePressValue = m_fMinValue - 1;
	49	setAttribute(Qt::WA_NoBackground);
	50	setMinimumSize(23, 116);
	51	setMaximumSize(23, 116);
	52	resize(23, 116);
55	53
	54	m_fMousePressValue = m_fMinValue - 1;
	55
56	56	// Background image
57	57	QString path = ":/data/fader_background.svg";
58		bool ok = m_back_original.load( path );
59		if( ok == false ) {
	58	bool ok = m_back_original.load(path);
	59	if (ok == false) {
60	60	qDebug() << "Fader: Error loading pixmap: " << path;
61	61	}
62	62
63	63	path = ":/data/fader_top.svg";
64		ok = m_top.load( path );
65		if( ok == false ) {
	64	ok = m_top.load(path);
	65	if (ok == false) {
66	66	qDebug() << "Fader: Error loading pixmap: " << path;
67	67	}
68	68
69	69	path = ":/data/fader_bottom.svg";
70		ok = m_bottom.load( path );
71		if( ok == false ) {
	70	ok = m_bottom.load(path);
	71	if (ok == false) {
72	72	qDebug() << "Fader: Error loading pixmap: " << path;
73	73	}
74	74
75	75	// Leds image
76	76	QString leds_path = ":/data/fader_leds.svg";
77		ok = m_leds_original.load( leds_path );
78		if( ok == false ) {
	77	ok = m_leds_original.load(leds_path);
	78	if (ok == false) {
79	79	qDebug() << "Error loading pixmap: " << ":/data/fader_background.svg";
80	80	}
81	81
82	82	// Knob image
83	83	QString knob_path = ":/data/fader_knob.png";
84		ok = m_knob.load( knob_path );
85		if( ok == false ) {
	84	ok = m_knob.load(knob_path);
	85	if (ok == false) {
86	86	qDebug() << "Error loading pixmap: " << ":/data/fader_knob.png";
87	87	}
88	88	}
90	90	{
91	91	// qDebug() << "[Destroy] Fader";
92	92	}
93		QWidget* Fader::getWidget() {
	93	QWidget* Fader::getWidget()
	94	{
94	95	return this;
95	96	}
96	97
97		void Fader::setFixedHeight ( int h ) {
98		QWidget::setFixedHeight(h);
	98	void Fader::setFixedHeight(int h)
	99	{
	100	QWidget::setFixedHeight(h);
99	101	m_back_scaled = m_back_original.scaled(width(), height()-30, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
100	102	m_leds_scaled = m_leds_original.scaled(width(), height()-30, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
101	103	}
102		void Fader::setFixedSize ( const QSize & s ) {
103		QWidget::setFixedSize(s);
	104	void Fader::setFixedSize(const QSize & s)
	105	{
	106	QWidget::setFixedSize(s);
104	107	m_back_scaled = m_back_original.scaled(width(), height()-30, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
105	108	m_leds_scaled = m_leds_original.scaled(width(), height()-30, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
106		}
107		void Fader::setFixedSize ( int w, int h ) {
108		QWidget::setFixedSize(w, h);
	109	}
	110	void Fader::setFixedSize(int w, int h)
	111	{
	112	QWidget::setFixedSize(w, h);
109	113	m_back_scaled = m_back_original.scaled(width(), height()-30, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
110	114	m_leds_scaled = m_leds_original.scaled(width(), height()-30, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
111	115	}
112	116
113		void Fader::mouseMoveEvent( QMouseEvent *ev )
	117	void Fader::mouseMoveEvent(QMouseEvent *ev)
114	118	{
115	119	if (m_fMousePressValue != m_fMinValue - 1) {
116	120	float fRange = m_fMaxValue - m_fMinValue;
117	121
118	122	float deltaY = ev->y() - m_fMousePressY;
119		float fNewValue = ( m_fMousePressValue - ( deltaY / height() * fRange ) );
	123	float fNewValue = (m_fMousePressValue - (deltaY / height() * fRange));
120	124
121		setValue( fNewValue, true );
	125	setValue(fNewValue, true);
122	126	}
123		/* if (ev->button() == Qt::LeftButton) {
124		float fVal = (float)( height() - ev->y() ) / (float)height();
125		fVal = fVal * ( m_fMaxValue - m_fMinValue );
126
127		fVal = fVal + m_fMinValue;
128
129		setValue( fVal, true );
130		}*/
	127	/* if (ev->button() == Qt::LeftButton) {
	128	float fVal = (float)( height() - ev->y() ) / (float)height();
	129	fVal = fVal * ( m_fMaxValue - m_fMinValue );
	130
	131	fVal = fVal + m_fMinValue;
	132
	133	setValue( fVal, true );
	134	}*/
131	135	}
132	136
133	137
134	138	void Fader::mousePressEvent(QMouseEvent *ev)
135	139	{
136		if (ev->button() == Qt::LeftButton) {
137		setCursor( QCursor( Qt::SizeVerCursor ) );
	140	if (ev->button() == Qt::LeftButton) {
	141	setCursor(QCursor(Qt::SizeVerCursor));
138	142
139		m_fMousePressValue = m_fValue;
140		m_fMousePressY = ev->y();
141		}
	143	m_fMousePressValue = m_fValue;
	144	m_fMousePressY = ev->y();
	145	}
142	146	}
143	147
144	148	void Fader::mouseReleaseEvent(QMouseEvent* ev)
145	149	{
146	150	if (ev->button() == Qt::LeftButton) {
147		setCursor( QCursor( Qt::ArrowCursor ) );
148		m_fMousePressValue = m_fMinValue - 1;
149		emit leftClick(ev);
	151	setCursor(QCursor(Qt::ArrowCursor));
	152	m_fMousePressValue = m_fMinValue - 1;
	153	emit leftClick(ev);
150	154	} else if (ev->button() == Qt::RightButton) {
151		emit rightClick(ev);
	155	emit rightClick(ev);
152	156	} else if (ev->button() == Qt::MidButton) {
153		emit middleClick(ev);
	157	emit middleClick(ev);
154	158	}
155	159	}
156	160
157		void Fader::mouseDoubleClickEvent(QMouseEvent* ev) {
	161	void Fader::mouseDoubleClickEvent(QMouseEvent* ev)
	162	{
158	163	if (ev->button() == Qt::LeftButton) {
159		float fVal = (float)( height() - ev->y() - 15.0 ) / ((float)height() - 30.0);
160		fVal = fVal * ( m_fMaxValue - m_fMinValue );
161
162		fVal = fVal + m_fMinValue;
163
164		setValue( fVal, true );
	164	float fVal = (float)(height() - ev->y() - 15.0) / ((float)height() - 30.0);
	165	fVal = fVal * (m_fMaxValue - m_fMinValue);
	166
	167	fVal = fVal + m_fMinValue;
	168
	169	setValue(fVal, true);
165	170	}
166	171	}
167	172
169	174	{
170	175	if (m_bUseIntSteps) {
171	176	if (p_bDirection) {
172		setValue( m_fValue + 1 * p_iStep, true );
	177	setValue(m_fValue + 1 * p_iStep, true);
173	178	} else {
174		setValue( m_fValue - 1 * p_iStep, true );
	179	setValue(m_fValue - 1 * p_iStep, true);
175	180	}
176	181	} else {
177	182	float step = 0.5;
178	183	if (m_fMinValue > -20) {
179		step = ( m_fMaxValue - m_fMinValue ) / 50.0;
	184	step = (m_fMaxValue - m_fMinValue) / 50.0;
180	185	}
181	186
182	187	if (p_bDirection) {
183		setValue( m_fValue + step * p_iStep, true );
	188	setValue(m_fValue + step * p_iStep, true);
184	189	} else {
185		setValue( m_fValue - step * p_iStep, true );
	190	setValue(m_fValue - step * p_iStep, true);
186	191	}
187	192	}
188	193	}
189	194
190		void Fader::setValue( float fVal, bool do_emit )
	195	void Fader::setValue(float fVal, bool do_emit)
191	196	{
192		if ( fVal > m_fMaxValue ) {
	197	if (fVal > m_fMaxValue) {
193	198	fVal = m_fMaxValue;
194		} else if ( fVal < m_fMinValue ) {
	199	} else if (fVal < m_fMinValue) {
195	200	fVal = m_fMinValue;
196	201	}
197	202
198		if ( m_bUseIntSteps ) {
	203	if (m_bUseIntSteps) {
199	204	fVal = (int)fVal;
200	205	}
201	206
202		if ( m_fValue != fVal ) {
	207	if (m_fValue != fVal) {
203	208	m_fValue = fVal;
204	209	update();
205	210	}
221	226
222	227
223	228	// in fact the external value is standanrd and internal in dB
224		void Fader::setDbValue( float val )
	229	void Fader::setDbValue(float val)
225	230	{
226	231	setValue(m_bLinDb ? lin2db(val, m_fMinValue) : lin2db(val));
227	232	}
228		void Fader::setDbPeak_L( float peak )
	233	void Fader::setDbPeak_L(float peak)
229	234	{
230	235	setPeak_L(m_bLinDb ? lin2db(peak, m_fMinPeak) : lin2db(peak));
231	236	}
233	238	{
234	239	return m_bLinDb ? db2lin(m_fPeakValue_L, m_fMinPeak) : db2lin(m_fPeakValue_L);
235	240	}
236		void Fader::setDbPeak_R( float peak )
	241	void Fader::setDbPeak_R(float peak)
237	242	{
238	243	setPeak_R(m_bLinDb ? lin2db(peak, m_fMinPeak) : lin2db(peak));
239	244	}
242	247	return m_bLinDb ? db2lin(m_fPeakValue_R, m_fMinPeak) : db2lin(m_fPeakValue_R);
243	248	}
244	249
245		void Fader::setDbMaxValue( float val )
	250	void Fader::setDbMaxValue(float val)
246	251	{
247	252	setMaxValue(m_bLinDb ? lin2db(val, m_fMinValue) : lin2db(val));
248	253	}
249		void Fader::setDbMinValue( float val )
	254	void Fader::setDbMinValue(float val)
250	255	{
251	256	setMinValue(m_bLinDb ? lin2db(val, m_fMinValue) : lin2db(val));
252	257	}
253		void Fader::setDbMaxPeak( float val )
	258	void Fader::setDbMaxPeak(float val)
254	259	{
255	260	setMaxPeak(m_bLinDb ? lin2db(val, m_fMinValue) : lin2db(val));
256	261	}
257		void Fader::setDbMinPeak( float val )
	262	void Fader::setDbMinPeak(float val)
258	263	{
259	264	setMinPeak(m_bLinDb ? lin2db(val, m_fMinValue) : lin2db(val));
260	265	}
262	267	///
263	268	/// Set peak value (0.0 .. 1.0)
264	269	///
265		void Fader::setPeak_L( float fPeak )
	270	void Fader::setPeak_L(float fPeak)
266	271	{
267		if ( fPeak < m_fMinPeak ) {
	272	if (fPeak < m_fMinPeak) {
268	273	fPeak = m_fMinPeak;
269		} else if ( fPeak > m_fMaxPeak ) {
	274	} else if (fPeak > m_fMaxPeak) {
270	275	fPeak = m_fMaxPeak;
271	276	}
272	277
273		if ( m_fPeakValue_L != fPeak) {
	278	if (m_fPeakValue_L != fPeak) {
274	279	m_fPeakValue_L = fPeak;
275	280	update();
276	281	}
280	285	///
281	286	/// Set peak value (0.0 .. 1.0)
282	287	///
283		void Fader::setPeak_R( float fPeak )
	288	void Fader::setPeak_R(float fPeak)
284	289	{
285		if ( fPeak < m_fMinPeak ) {
	290	if (fPeak < m_fMinPeak) {
286	291	fPeak = m_fMinPeak;
287		} else if ( fPeak > m_fMaxPeak ) {
	292	} else if (fPeak > m_fMaxPeak) {
288	293	fPeak = m_fMaxPeak;
289	294	}
290	295
291		if ( m_fPeakValue_R != fPeak ) {
	296	if (m_fPeakValue_R != fPeak) {
292	297	m_fPeakValue_R = fPeak;
293	298	update();
294	299	}
299	304	QPainter painter(this);
300	305
301	306	// background
302		painter.drawPixmap( QRect(0, 15, width(), height()-30), m_back_scaled, QRect(0, 0, width(), height()-30));
303		painter.drawPixmap( QRect(0, 0, width(), 15), m_top, QRect(0, 0, width(), 15) );
304		painter.drawPixmap( QRect(0, height() - 15, width(), 15), m_bottom, QRect(0, 0, width(), 15) );
	307	painter.drawPixmap(QRect(0, 15, width(), height()-30), m_back_scaled, QRect(0, 0, width(), height()-30));
	308	painter.drawPixmap(QRect(0, 0, width(), 15), m_top, QRect(0, 0, width(), 15));
	309	painter.drawPixmap(QRect(0, height() - 15, width(), 15), m_bottom, QRect(0, 0, width(), 15));
305	310
306	311	// peak leds
307		if (m_fMaxPeak > m_fMinPeak) {
308		float realPeak_L = m_fPeakValue_L - m_fMinPeak;
309		int peak_L = (int)(height() - 30 - ( realPeak_L / ( m_fMaxPeak - m_fMinPeak ) ) * (height() - 30));
310		if (peak_L > height() - 30) {
311		peak_L = height() - 30;
312		}
313		painter.drawPixmap( QRect( 0, peak_L + 15, width() / 2, height() - 30 - peak_L ), m_leds_scaled,
314		QRect( 0, peak_L , width() / 2, height() - 30 - peak_L ) );
315
316
317		float realPeak_R = m_fPeakValue_R - m_fMinPeak;
318		int peak_R = (int)(height() - 30 - ( realPeak_R / ( m_fMaxPeak - m_fMinPeak ) ) * (height() - 30));
319		if (peak_R > height() - 30) {
320		peak_R = height() - 30;
321		}
322		painter.drawPixmap( QRect( width() / 2, peak_R + 15, width() / 2, height() - 30 - peak_R ), m_leds_scaled,
323		QRect( width() / 2, peak_R , width() / 2, height() - 30 - peak_R ) );
324		}
	312	if (m_fMaxPeak > m_fMinPeak) {
	313	float realPeak_L = m_fPeakValue_L - m_fMinPeak;
	314	int peak_L = (int)(height() - 30 - (realPeak_L / (m_fMaxPeak - m_fMinPeak)) * (height() - 30));
	315	if (peak_L > height() - 30) {
	316	peak_L = height() - 30;
	317	}
	318	painter.drawPixmap(QRect(0, peak_L + 15, width() / 2, height() - 30 - peak_L), m_leds_scaled,
	319	QRect(0, peak_L , width() / 2, height() - 30 - peak_L));
325	320
	321
	322	float realPeak_R = m_fPeakValue_R - m_fMinPeak;
	323	int peak_R = (int)(height() - 30 - (realPeak_R / (m_fMaxPeak - m_fMinPeak)) * (height() - 30));
	324	if (peak_R > height() - 30) {
	325	peak_R = height() - 30;
	326	}
	327	painter.drawPixmap(QRect(width() / 2, peak_R + 15, width() / 2, height() - 30 - peak_R), m_leds_scaled,
	328	QRect(width() / 2, peak_R , width() / 2, height() - 30 - peak_R));
	329	}
	330
326	331	if (!m_bWithoutKnob) {
327	332	// knob
328	333	static const uint knob_height = 29;
332	337
333	338	float realVal = m_fValue - m_fMinValue;
334	339
335		uint knob_y = (uint)( height() - ( ( height() - 30 ) * ( realVal / fRange ) ) );
	340	uint knob_y = (uint)(height() - ((height() - 30) * (realVal / fRange)));
336	341
337		painter.drawPixmap( QRect( 4, knob_y - knob_height, knob_width, knob_height), m_knob, QRect( 0, 0, knob_width, knob_height ) );
	342	painter.drawPixmap(QRect(4, knob_y - knob_height, knob_width, knob_height), m_knob, QRect(0, 0, knob_width, knob_height));
338	343	}
339	344	}
340	345
341	346
342		void Fader::setMinValue( float fMin )
	347	void Fader::setMinValue(float fMin)
343	348	{
344	349	m_fMinValue = fMin;
345		m_fMousePressValue = m_fMinValue - 1;
	350	m_fMousePressValue = m_fMinValue - 1;
346	351	}
347	352
348	353
349		void Fader::setMaxValue( float fMax )
	354	void Fader::setMaxValue(float fMax)
350	355	{
351	356	m_fMaxValue = fMax;
352	357	}
353	358
354	359
355		void Fader::setMaxPeak( float fMax )
	360	void Fader::setMaxPeak(float fMax)
356	361	{
357	362	m_fMaxPeak = fMax;
358	363	}
359	364
360	365
361		void Fader::setMinPeak( float fMin )
	366	void Fader::setMinPeak(float fMin)
362	367	{
363	368	m_fMinPeak = fMin;
364	369	}
365	370

Logiciel libre. Free software.

Browse the code