From 2e509a546f14c8c7e7ff05cbceb21e3a0bb2f674 Mon Sep 17 00:00:00 2001
From: iFriendGit <74499837+iFriendGit@users.noreply.github.com>
Date: Wed, 16 Nov 2022 15:09:39 +0100
Subject: [PATCH] Update mixerdlg.cpp

part of changes for https://github.com/hselasky/hpsjam/issues/17#issuecomment-1317012178
---
 src/mixerdlg.cpp | 982 ++++++++++++++---------------------------------
 1 file changed, 285 insertions(+), 697 deletions(-)

diff --git a/src/mixerdlg.cpp b/src/mixerdlg.cpp
index 5727cef..800d134 100644
--- a/src/mixerdlg.cpp
+++ b/src/mixerdlg.cpp
@@ -23,716 +23,304 @@
  * SUCH DAMAGE.
  */
 
-#include <QMutexLocker>
-#include <QMouseEvent>
-#include <QKeyEvent>
-#include <QPainter>
-#include <QFontMetrics>
-
-#include "hpsjam.h"
-#include "peer.h"
-#include "mixerdlg.h"
-#include "protocol.h"
-#include "clientdlg.h"
-
-HpsJamIcon :: HpsJamIcon(const QString &_fname) :
-    fname(_fname)
-{
-	sel = false;
-	enabled = true;
-	if (!fname.isEmpty())
-		svg.load(fname);
-	setFixedSize(64,64);
-	updateBackground();
-}
-
-void
-HpsJamIcon :: updateBackground()
-{
-	if (sel)
-		t.rgb = QColor(255,255,255,192);
-	else
-		t.rgb = QColor(192,192,192,128);
-}
-
-void
-HpsJamIcon :: mouseReleaseEvent(QMouseEvent *event)
-{
-	if (event->button() != Qt::LeftButton)
-		return;
-	if (enabled)
-		emit selected();
-}
-
-void
-HpsJamIcon :: paintEvent(QPaintEvent *event)
-{
-	if (enabled)
-		HpsJamRWidget::paintEvent(event);
-
-	QPainter paint(this);
-
-	paint.setRenderHints(QPainter::Antialiasing, true);
-	svg.render(&paint);
-	paint.end();
-
-	if (!enabled)
-		HpsJamRWidget::paintEvent(event);
-}
-
-void
-HpsJamIcon :: setSelection(bool state)
-{
-	if (sel == state)
-		return;
-	sel = state;
-	updateBackground();
-	update();
-	emit selected();
-}
-
-HpsJamSlider :: HpsJamSlider()
-{
-	target = QRect(0,0,0,0);
-	start = QPoint(0,0);
-	value = 0;
-	pan = 0;
-	gain = 0;
-	level[0] = 0;
-	level[1] = 0;
-	active = false;
-	setMinimumSize(dsize, 128);
-	setMaximumSize(65535,65535);
-}
-
-void
-HpsJamSlider :: setValue(float _value)
-{
-	if (_value != value) {
-		value = _value;
+#ifndef _HPSJAM_MIXERDLG_H_
+#define	_HPSJAM_MIXERDLG_H_
+
+#include <QObject>
+#include <QWidget>
+#include <QPushButton>
+#include <QGridLayout>
+#include <QRect>
+#include <QPoint>
+#include <QSvgRenderer>
+#include <QLabel>
+#include <QScrollArea>
+#include <QSizePolicy>
+
+#include "texture.h"
+
+#include "eqdlg.h"
+
+class HpsJamIcon : public HpsJamRWidget {
+	Q_OBJECT
+public:
+	HpsJamIcon(const QString & = QString());
+
+	QString fname;
+	QSvgRenderer svg;
+	bool sel;
+	bool enabled;
+	void updateBackground();
+	void paintEvent(QPaintEvent *);
+	void mouseReleaseEvent(QMouseEvent *);
+	void setSelection(bool);
+	void setEnabled(bool state) {
+		if (enabled == state)
+			return;
+		enabled = state;
+		updateBackground();
 		update();
-		emit valueChanged();
-	}
-}
-
-void
-HpsJamSlider :: setPan(float _pan)
-{
-	if (_pan != pan) {
-		pan = _pan;
-		update();
-	}
-}
-
-void
-HpsJamSlider :: setGain(int _gain)
-{
-	if (_gain != gain) {
-		gain = _gain;
-		update();
-	}
-}
-
-void
-HpsJamSlider :: adjustPan(float _pan)
-{
-	pan += _pan;
-
-	if (pan > 1.0f)
-		pan = 1.0f;
-	else if (pan < -1.0f)
-		pan = -1.0f;
-
-	if (_pan != 0.0f) {
-		/* align to zero when crossing zero */
-		if (pan - _pan < 0.0f && pan > 0.0f)
-			pan = 0.0f;
-		else if (pan - _pan > 0.0f && pan < 0.0f)
-			pan = 0.0f;
-
-		update();
-	}
-}
-
-void
-HpsJamSlider :: setLevel(float _left, float _right)
-{
-	if (_left != level[0] || _right != level[1]) {
-		level[0] = _left;
-		level[1] = _right;
-		update();
-	}
-}
-
-void
-HpsJamSlider :: adjustGain(int delta)
-{
-	if (delta == 0)
-		return;
-
-	int temp = gain + delta;
-
-	/* range check value */
-	if (temp < -16)
-		temp = -16;
-	else if (temp > 15)
-		temp = 15;
-
-	gain = temp;
-	update();
-}
-
-void
-HpsJamSlider :: paintEvent(QPaintEvent *event)
-{
-	QRect frame(0, 0, width(), height());
-
-	QPainter paint(this);
+	};
+signals:
+	void selected();
+};
 
-	paint.setRenderHints(QPainter::Antialiasing, 1);
+class HpsJamSlider : public QWidget {
+	Q_OBJECT
+public:
+	static constexpr unsigned dsize = 16;	/* dot size in pixels */
 
-	/* select foreground color */
-	static const QColor fg(0, 0, 0);
-	static const QColor fg_t(0, 0, 0, 127);
+	HpsJamSlider();
 
-	/* select background color */
-	static const QColor bg(255, 255, 255, 127);
+	bool active;
+	QRect target;
+	QPoint start;
+	float value;
+	float pan;
+	float level[2];
+	int gain;
+
+	void setValue(float);
+	void setPan(float);
+	void setGain(int);
+	void adjustPan(float);
+	void adjustGain(int);
+	void setLevel(float, float);
+
+	void paintEvent(QPaintEvent *);
+        void mousePressEvent(QMouseEvent *);
+        void mouseMoveEvent(QMouseEvent *);
+        void mouseReleaseEvent(QMouseEvent *);
+signals:
+	void valueChanged();
+};
+
+class HpsJamPan : public QObject {
+	Q_OBJECT
+public:
+	HpsJamPushButton b_l;
+	HpsJamPushButton b_r;
+
+	HpsJamPan() : b_l(QString("L")), b_r(QString("R")) {
+		connect(&b_l, SIGNAL(released()), this, SLOT(handle_pan_left()));
+		connect(&b_r, SIGNAL(released()), this, SLOT(handle_pan_right()));
+	};
 
-	/* select gain color */
-	static const QColor gc(192, 192, 192);
+public slots:
+	void handle_pan_left();
+	void handle_pan_right();
+signals:
+	void valueChanged(int);
+};
+
+class HpsJamGain : public QObject {
+	Q_OBJECT
+public:
+	HpsJamPushButton b_inc;
+	HpsJamPushButton b_dec;
+
+	HpsJamGain() :
+	    b_inc(QString("+")), b_dec(QString("-")) {
+		setValue(0);
+		connect(&b_inc, SIGNAL(released()), this, SLOT(handle_gain_up()));
+		connect(&b_dec, SIGNAL(released()), this, SLOT(handle_gain_down()));
+	};
 
-	static const QColor lc[3] = {
-		QColor(0, 255, 0),
-		QColor(255, 255, 0),
-		QColor(255, 0, 0),
+	void setValue(int x) {
+		b_inc.setEnabled(x < 15);
+		b_dec.setEnabled(x > -16);
 	};
 
-	paint.fillRect(frame, bg);
+public slots:
+	void handle_gain_up();
+	void handle_gain_down();
+signals:
+	void valueChanged(int);
+};
+
+class HpsJamStrip : public HpsJamGroupBox {
+	Q_OBJECT
+public:
+	HpsJamStrip();
+
+	int id;
+
+	QLabel w_name;
+	HpsJamIcon w_icon;
+	HpsJamGain w_gain;
+	HpsJamPan w_pan;
+	HpsJamSlider w_slider;
+	HpsJamEqualizer w_eq;
+	HpsJamPushButton b_eq;
+	HpsJamPushButton b_inv;
+	HpsJamPushButton b_mute;
+	HpsJamPushButton b_solo;
+	QString description;
+
+	void init() {
+		w_name.setText(QString());
+		w_icon.svg.load(QByteArray());
+		w_icon.update();
+		HPSJAM_NO_SIGNAL(w_slider,setValue(1));
+		HPSJAM_NO_SIGNAL(w_slider,setPan(0));
+		HPSJAM_NO_SIGNAL(w_slider,setLevel(0,0));
+		HPSJAM_NO_SIGNAL(w_slider,setGain(0));
+		w_eq.handle_disable();
+		HPSJAM_NO_SIGNAL(b_inv,setFlat(false));
+		HPSJAM_NO_SIGNAL(b_mute,setFlat(false));
+		HPSJAM_NO_SIGNAL(b_solo,setFlat(false));
+		HPSJAM_NO_SIGNAL(w_gain,setValue(0));
+		titleRegen();
+	};
 
-	const unsigned dots = height() / dsize;
-	if (dots < 2)
-		return;
+	void titleRegen() {
+		QString bits;
+
+		if (b_inv.isFlat())
+			bits += "I";
+		if (b_mute.isFlat())
+			bits += "M";
+		if (b_solo.isFlat())
+			bits += "S";
+		if (w_eq.edit.toPlainText().trimmed() != QString(
+			"pre-delay 0.0 ms\n"
+			"EQ-size 2.0 ms\n"
+		))
+			bits += "E";		if (w_slider.pan < 0.0f)
+			bits += "L";
+		else if (w_slider.pan > 0.0f)
+			bits += "R";
+		if (description == "Balance") {
+			if (w_slider.value > 0.0f)
+				bits += "G";
+		} else {
+			if (w_slider.value < 1.0f)
+				bits += "G";
+		}
+		if (w_slider.gain != 0) {
+			bits += QString("%1%2")
+			  .arg(w_slider.gain > 0 ? "+" : "-")
+			  .arg(w_slider.gain < 0 ? -w_slider.gain : w_slider.gain);
+		}
 
-	/* compute height of gain bar */
-	int gh = height() - (height() * (gain + 16)) / 31;
-	paint.fillRect(QRect(0, height() / 2 - 2, width(), 1), gc);
-	paint.fillRect(QRect(0, gh, dsize, height() - gh), gc);
-	paint.fillRect(QRect(0, gh, dsize, 2), fg);
+		if (bits.isEmpty())
+			setTitle(description);
+		else
+			setTitle(description + QString(" ") + bits);
+	};
 
-	const unsigned dist[3] = {
-		dots - (dots + 7) / 8 - (dots + 4) / 5,
-		dots - (dots + 7) / 8,
-		dots,
+	uint8_t getBits() {
+		uint8_t ret = HPSJAM_BIT_GAIN_SET(w_slider.gain);
+		if (b_inv.isFlat())
+			ret |= HPSJAM_BIT_INVERT;
+		if (b_mute.isFlat())
+			ret |= HPSJAM_BIT_MUTE;
+		if (b_solo.isFlat())
+			ret |= HPSJAM_BIT_SOLO;
+		return (ret);
 	};
 
-	unsigned ldots = dots * level[0];
-	unsigned y;
-
-	for (unsigned x = y = 0; x != ldots; x++) {
-		while (dist[y] == x)
-			y++;
-		paint.setPen(QPen(QBrush(lc[y]), dsize,
-		    Qt::SolidLine, Qt::RoundCap));
-		paint.drawPoint(QPoint(width() / 2 - dsize / 2, height() - x * dsize - dsize / 2));
-	}
-
-	ldots = dots * level[1];
-
-	for (unsigned x = y = 0; x != ldots; x++) {
-		while (dist[y] == x)
-			y++;
-		paint.setPen(QPen(QBrush(lc[y]), dsize,
-		    Qt::SolidLine, Qt::RoundCap));
-		paint.drawPoint(QPoint(width() / 2 + dsize / 2, height() - x * dsize - dsize / 2));
-	}
-
-	target = QRect(2, (1.0f - value) * (height() - dsize), width() - 4, dsize);
-
-	paint.setPen(QPen(fg, 2));
-	paint.setBrush(QBrush(fg_t));
-	paint.drawRect(target);
-
-	int p_off = pan * ((target.width() - dsize) / 2);
-
-	QRect circle((target.width() - dsize) / 2 + p_off,
-		     (1.0f - value) * (height() - dsize),
-		     dsize, dsize);
-	paint.setBrush(QBrush(p_off ? bg : fg));
-	paint.drawEllipse(circle);
-}
-
-void
-HpsJamSlider :: mousePressEvent(QMouseEvent *event)
-{
-	if (event->button() != Qt::LeftButton)
-		return;
-	if (target.contains(event->pos())) {
-		active = true;
-		start = event->pos();
-	}
-}
-
-void
-HpsJamSlider :: mouseMoveEvent(QMouseEvent *event)
-{
-	if (height() < (int)dsize)
-		return;
-	if (active == true) {
-		const QPoint delta = event->pos() - start;
-		const float offset = (float)delta.y() / (float)(height() - dsize);
-
-		start = event->pos();
-
-		value -= offset;
-		if (value < 0.0f)
-			value = 0.0f;
-		else if (value > 1.0f)
-			value = 1.0f;
-
-		if (offset != 0.0f) {
-			emit valueChanged();
-			update();
+public slots:
+	void handleSlider();
+	void handleSolo();
+	void handleMute();
+	void handleEQShow();
+	void handleEQApply();
+	void handleInv();
+	void handlePan(int);
+	void handleGain(int);
+
+signals:
+	void gainChanged(int);
+	void panChanged(int);
+	void bitsChanged(int);
+	void eqChanged(int);
+};
+
+class HpsJamMixer : public QScrollArea {
+	Q_OBJECT
+public:
+	HpsJamMixer() : gl(&w_main) {
+		my_peer = 0;
+		mixer_cols = HPSJAM_PEERS_MAX + 1;
+		setWidgetResizable(true);
+
+		self_strip.description = tr("Balance");
+		self_strip.titleRegen();
+		self_strip.b_solo.setEnabled(false);
+		self_strip.w_gain.b_inc.setEnabled(false);
+		self_strip.w_gain.b_dec.setEnabled(false);
+		self_strip.w_icon.setSelection(true);
+
+		connect(&self_strip, SIGNAL(eqChanged(int)), this, SLOT(handle_local_eq_changed()));
+		self_strip.id = 0;
+		gl.addWidget(&self_strip, 0, 0);
+		for (unsigned x = 0; x != HPSJAM_PEERS_MAX; x++) {
+			peer_strip[x].description = QString("Mix%1").arg(1 + x);
+			peer_strip[x].titleRegen();
+			peer_strip[x].id = x;
+			peer_strip[x].hide();
+			peer_strip[x].w_slider.setValue(1);
+
+			addPeer(x);
+			connect(peer_strip + x, SIGNAL(bitsChanged(int)), this, SLOT(handle_bits_changed(int)));
+			connect(peer_strip + x, SIGNAL(gainChanged(int)), this, SLOT(handle_gain_changed(int)));
+			connect(peer_strip + x, SIGNAL(panChanged(int)), this, SLOT(handle_pan_changed(int)));
+			connect(peer_strip + x, SIGNAL(eqChanged(int)), this, SLOT(handle_eq_changed(int)));
 		}
-	}
-}
-
-void
-HpsJamSlider :: mouseReleaseEvent(QMouseEvent *event)
-{
-	if (event->button() != Qt::LeftButton)
-		return;
-
-	if (active) {
-		mouseMoveEvent(event);
-		active = false;
-	}
-}
-
-void
-HpsJamPan :: handle_pan_left()
-{
-	emit valueChanged(-1);
-}
-
-void
-HpsJamPan :: handle_pan_right()
-{
-	emit valueChanged(+1);
-}
-
-void
-HpsJamGain :: handle_gain_up()
-{
-	emit valueChanged(+1);
-}
-
-void
-HpsJamGain :: handle_gain_down()
-{
-	emit valueChanged(-1);
-}
-
-HpsJamStrip :: HpsJamStrip() :
-    b_eq(tr("EQ\nDELAY")),
-    b_inv(tr("INV")),
-    b_mute(tr("MUTE")),
-    b_solo(tr("SOLO"))
-{
-	id = -1;
-
-	QFontMetrics m(font());
-
-	int temp = m.boundingRect(QChar('_')).width() * 10 + 24;
-	if (temp < 128)
-		temp = 128;
-
-	setFixedWidth(temp);
-
-	connect(&w_gain, SIGNAL(valueChanged(int)), this, SLOT(handleGain(int)));
-	connect(&w_pan, SIGNAL(valueChanged(int)), this, SLOT(handlePan(int)));
-	connect(&w_slider, SIGNAL(valueChanged()), this, SLOT(handleSlider()));
-	connect(&b_eq, SIGNAL(released()), this, SLOT(handleEQShow()));
-	connect(&w_eq.b_apply, SIGNAL(released()), this, SLOT(handleEQApply()));
-	connect(&b_inv, SIGNAL(released()), this, SLOT(handleInv()));
-	connect(&b_solo, SIGNAL(pressed()), this, SLOT(handleSolo()));
-	connect(&b_mute, SIGNAL(pressed()), this, SLOT(handleMute()));
-
-	gl.addWidget(&w_icon, 0,0, 1,2, Qt::AlignCenter);
-	gl.addWidget(&w_name, 1,0, 1,2, Qt::AlignCenter);
-	gl.addWidget(&b_eq, 2,0,1,2);
-	gl.addWidget(&b_inv, 3,0,1,2);
-	gl.addWidget(&w_gain.b_inc, 4,0,1,1);
-	gl.addWidget(&w_gain.b_dec, 4,1,1,1);
-	gl.addWidget(&w_pan.b_l, 5,0,1,1);
-	gl.addWidget(&w_pan.b_r, 5,1,1,1);
-	gl.addWidget(&w_slider, 6,0,1,2);
-	gl.setRowStretch(6,1);
-	gl.addWidget(&b_solo, 7,0,1,2);
-	gl.addWidget(&b_mute, 8,0,1,2);
-}
-
-void
-HpsJamStrip :: handleEQShow()
-{
-	w_eq.setWindowTitle(QString("HPS JAM equalizer for ") + title());
-	w_eq.show();
-	w_eq.edit.setFocus();
-}
-
-void
-HpsJamStrip :: handleEQApply()
-{
-	titleRegen();
-
-	emit eqChanged(id);
-}
-
-void
-HpsJamStrip :: handleSlider()
-{
-	titleRegen();
-
-	emit gainChanged(id);
-}
-
-void
-HpsJamStrip :: handlePan(int delta)
-{
-	w_slider.adjustPan(delta / 16.0f);
-
-	titleRegen();
-
-	emit panChanged(id);
-}
-
-void
-HpsJamStrip :: handleGain(int delta)
-{
-	w_slider.adjustGain(delta);
-	w_gain.setValue(w_slider.gain);
-
-	titleRegen();
-
-	emit bitsChanged(id);
-}
-
-void
-HpsJamStrip :: handleInv()
-{
-	if (b_inv.isFlat())
-		b_inv.setFlat(false);
-	else
-		b_inv.setFlat(true);
-
-	titleRegen();
-
-	emit bitsChanged(id);
-}
-
-void
-HpsJamStrip :: handleSolo()
-{
-	if (b_solo.isFlat())
-		b_solo.setFlat(false);
-	else
-		b_solo.setFlat(true);
-
-	titleRegen();
-
-	emit bitsChanged(id);
-}
-
-void
-HpsJamStrip :: handleMute()
-{
-	if (b_mute.isFlat())
-		b_mute.setFlat(false);
-	else
-		b_mute.setFlat(true);
-
-	titleRegen();
-
-	emit bitsChanged(id);
-}
-
-void
-HpsJamMixer :: keyPressEvent(QKeyEvent *event)
-{
-	switch (event->key()) {
-	case Qt::Key_L:
-		self_strip.w_pan.b_l.animateClick();
-		break;
-	case Qt::Key_R:
-		self_strip.w_pan.b_r.animateClick();
-		break;
-	case Qt::Key_M:
-		self_strip.b_mute.animateClick();
-		break;
-	case Qt::Key_I:
-		self_strip.b_inv.animateClick();
-		break;
-	case Qt::Key_1:
-		self_strip.w_slider.setValue(0.0f / 8.0f);
-		break;
-	case Qt::Key_2:
-		self_strip.w_slider.setValue(1.0f / 8.0f);
-		break;
-	case Qt::Key_3:
-		self_strip.w_slider.setValue(2.0f / 8.0f);
-		break;
-	case Qt::Key_4:
-		self_strip.w_slider.setValue(3.0f / 8.0f);
-		break;
-	case Qt::Key_5:
-		self_strip.w_slider.setValue(4.0f / 8.0f);
-		break;
-	case Qt::Key_6:
-		self_strip.w_slider.setValue(5.0f / 8.0f);
-		break;
-	case Qt::Key_7:
-		self_strip.w_slider.setValue(6.0f / 8.0f);
-		break;
-	case Qt::Key_8:
-		self_strip.w_slider.setValue(7.0f / 8.0f);
-		break;
-	case Qt::Key_9:
-		self_strip.w_slider.setValue(8.0f / 8.0f);
-		break;
-	case Qt::Key_E:
-		self_strip.b_eq.animateClick();
-		break;
-	case Qt::Key_P:
-		if (my_peer != 0)
-			my_peer->b_mute.animateClick();
-		break;
-	default:
-		break;
-	}
-}
-
-void
-HpsJamMixer :: handle_fader_level(uint8_t mix, uint8_t index, float left, float right)
-{
-	/* make scale logarithmic */
-	left = level_encode(left);
-	right = level_encode(right);
-
-	switch (mix) {
-	case 0:
-		HPSJAM_NO_SIGNAL(peer_strip[index].w_slider,setLevel(left, right));
-		break;
-	case 255:
-		HPSJAM_NO_SIGNAL(self_strip.w_slider,setLevel(left, right));
-		break;
-	default:
-		break;
-	}
-}
-
-void
-HpsJamMixer :: handle_fader_self(uint8_t mix, uint8_t index)
-{
-	switch (mix) {
-	case 0:
-		my_peer = peer_strip + index;
-		if (hpsjam_mute_peer_audio) {
-			my_peer->show();
-			my_peer->b_mute.animateClick();
+		setWidget(&w_main);
+		viewport()->setAutoFillBackground(false);
+		w_main.setAutoFillBackground(false);
+	};
+	void keyPressEvent(QKeyEvent *event);
+	QWidget w_main;
+	QGridLayout gl;
+	HpsJamStrip self_strip;
+	HpsJamStrip peer_strip[HPSJAM_PEERS_MAX];
+	HpsJamStrip *my_peer;
+	unsigned mixer_cols;
+	void enable(unsigned index);
+	void disable(unsigned index);
+	void init() {
+		my_peer = 0;
+		for (unsigned x = 0; x != HPSJAM_PEERS_MAX; x++) {
+			peer_strip[x].init();
+			peer_strip[x].hide();
 		}
-		break;
-	default:
-		break;
-	}
-}
-
-void
-HpsJamMixer :: handle_fader_name(uint8_t mix, uint8_t index, QString *str)
-{
-	switch (mix) {
-	case 0:
-		HPSJAM_NO_SIGNAL(peer_strip[index].w_name,setText(*str));
-		enable(index);
-		break;
-	case 255:
-		HPSJAM_NO_SIGNAL(self_strip.w_name,setText(*str));
-		break;
-	default:
-		break;
-	}
-	delete str;
-}
-
-void
-HpsJamMixer :: handle_fader_icon(uint8_t mix, uint8_t index, QByteArray *ba)
-{
-	switch (mix) {
-	case 0:
-		peer_strip[index].w_icon.svg.load(*ba);
-		peer_strip[index].w_icon.update();
-		break;
-	case 255:
-		self_strip.w_icon.svg.load(*ba);
-		self_strip.w_icon.update();
-		break;
-	default:
-		break;
-	}
-	delete ba;
-}
-void
-HpsJamMixer :: handle_fader_gain(uint8_t mix, uint8_t index, float gain)
-{
-	switch (mix) {
-	case 0:
-		HPSJAM_NO_SIGNAL(peer_strip[index].w_slider,setValue(gain));
-		peer_strip[index].titleRegen();
-		break;
-	case 255:
-		HPSJAM_NO_SIGNAL(self_strip.w_slider,setValue(gain));
-		self_strip.titleRegen();
-		break;
-	default:
-		break;
-	}
-}
-
-void
-HpsJamMixer :: handle_fader_pan(uint8_t mix, uint8_t index, float pan)
-{
-	switch (mix) {
-	case 0:
-		HPSJAM_NO_SIGNAL(peer_strip[index].w_slider,setPan(pan));
-		peer_strip[index].titleRegen();
-		break;
-	case 255:
-		HPSJAM_NO_SIGNAL(self_strip.w_slider,setPan(pan));
-		self_strip.titleRegen();
-		break;
-	default:
-		break;
-	}
-}
-
-void
-HpsJamMixer :: handle_fader_eq(uint8_t mix, uint8_t index, QString *str)
-{
-	switch (mix) {
-	case 0:
-		HPSJAM_NO_SIGNAL(peer_strip[index].w_eq.edit,setText(*str));
-		peer_strip[index].titleRegen();
-		break;
-	case 255:
-		HPSJAM_NO_SIGNAL(self_strip.w_eq.edit,setText(*str));
-		self_strip.titleRegen();
-		break;
-	default:
-		break;
-	}
-	delete str;
-}
-
-void
-HpsJamMixer :: handle_fader_disconnect(uint8_t mix, uint8_t index)
-{
-	switch (mix) {
-	case 0:
-		peer_strip[index].init();
-		disable(index);
-		break;
-	case 255:
-		self_strip.init();
-		break;
-	default:
-		break;
-	}
-}
-
-void
-HpsJamMixer :: handle_bits_changed(int id)
-{
-	struct hpsjam_packet_entry *ptr;
-	char bits;
-
-	bits = peer_strip[id].getBits();
-
-	ptr = new struct hpsjam_packet_entry;
-	ptr->packet.type = HPSJAM_TYPE_FADER_BITS_REQUEST;
-	ptr->packet.setFaderData(0, id, &bits, 1);
-
-	hpsjam_client_peer->send_single_pkt(ptr);
-}
-
-void
-HpsJamMixer :: handle_gain_changed(int id)
-{
-	struct hpsjam_packet_entry *ptr;
-	float gain;
-
-	gain = peer_strip[id].w_slider.value;
-
-	ptr = new struct hpsjam_packet_entry;
-	ptr->packet.type = HPSJAM_TYPE_FADER_GAIN_REQUEST;
-	ptr->packet.setFaderValue(0, id, &gain, 1);
-
-	hpsjam_client_peer->send_single_pkt(ptr);
-}
-
-void
-HpsJamMixer :: handle_pan_changed(int id)
-{
-	struct hpsjam_packet_entry *ptr;
-	float pan;
+	};
+	void addPeer(unsigned x) {
+		gl.addWidget(peer_strip + x, (1 + x) / mixer_cols, (1 + x) % mixer_cols);
+	};
+	unsigned getMixerCols() {
+		return (mixer_cols);
+	};
+	void setMixerCols(unsigned _value) {
+		/* check for invalid parameter */
+		if (_value <= 0 || _value >= 65536)
+			return;
+		mixer_cols = _value;
+		for (unsigned x = 0; x != HPSJAM_PEERS_MAX; x++)
+			gl.removeWidget(peer_strip + x);
+		for (unsigned x = 0; x != HPSJAM_PEERS_MAX; x++)
+			addPeer(x);
+	};
 
-	pan = peer_strip[id].w_slider.pan;
-
-	ptr = new struct hpsjam_packet_entry;
-	ptr->packet.type = HPSJAM_TYPE_FADER_PAN_REQUEST;
-	ptr->packet.setFaderValue(0, id, &pan, 1);
-
-	hpsjam_client_peer->send_single_pkt(ptr);
-}
-
-void
-HpsJamMixer :: handle_eq_changed(int id)
-{
-	struct hpsjam_packet_entry *ptr;
-	QByteArray eq = peer_strip[id].w_eq.edit.toPlainText().toLatin1();
-
-	if (eq.length() > 255)
-		return;
-
-	ptr = new struct hpsjam_packet_entry;
-	ptr->packet.type = HPSJAM_TYPE_FADER_EQ_REQUEST;
-	ptr->packet.setFaderData(0, id, eq.constData(), eq.length());
-
-	hpsjam_client_peer->send_single_pkt(ptr);
-}
-
-void
-HpsJamMixer :: handle_local_eq_changed()
-{
-	QByteArray eq = self_strip.w_eq.edit.toPlainText().toLatin1();
-
-	QMutexLocker locker(&hpsjam_client_peer->lock);
-	hpsjam_client_peer->local_eq.init(eq.constData());
-}
-
-void
-HpsJamMixer :: enable(unsigned index)
-{
-	peer_strip[index].setCollapsed(false);
-	peer_strip[index].show();
-	if (!hpsjam_client->w_mixer->isVisible())
-		hpsjam_client->b_mixer.setFlashing();
-
-	hpsjam_client->playNewUser();
-}
-
-void
-HpsJamMixer :: disable(unsigned index)
-{
-	peer_strip[index].init();
-	peer_strip[index].hide();
-	if (!hpsjam_client->w_mixer->isVisible())
-		hpsjam_client->b_mixer.setFlashing();
-}
+public slots:
+	void handle_fader_level(uint8_t, uint8_t, float, float);
+	void handle_fader_name(uint8_t, uint8_t, QString *);
+	void handle_fader_icon(uint8_t, uint8_t, QByteArray *);
+	void handle_fader_gain(uint8_t, uint8_t, float);
+	void handle_fader_pan(uint8_t, uint8_t, float);
+	void handle_fader_eq(uint8_t, uint8_t, QString *);
+	void handle_fader_self(uint8_t, uint8_t);
+	void handle_fader_disconnect(uint8_t, uint8_t);
+
+	void handle_bits_changed(int);
+	void handle_gain_changed(int);
+	void handle_pan_changed(int);
+	void handle_eq_changed(int);
+
+	void handle_local_eq_changed();
+};
+
+#endif		/* _HPSJAM_MIXERDLG_H_ */