code cleanup; channels callback coalesced again

src/back/backlasses.cpp

@@ -55,18 +55,16 @@ HRESULT EndpointCallback::OnNotify(PAUDIO_VOLUME_NOTIFICATION_DATA pNotify) {
     } else {
 		log_debugcpp("Onnanokotify says Stored: " << guid->data1);
 		log_debugcpp("Onnanokotify says Grace of God: " << eventData.guidEventContext.Data1);
-		osh->toggleFrontEvents(this->ep->getIndex(), true);
 		osh->updateMuteCallback(this->ep->getIndex(), eventData.bMuted);
-		osh->updateMainVolumeCallback(this->ep->getIndex(), eventData.fMasterVolume);
+		osh->updateVolumeCallback(this->ep->getIndex(), AudioChannel::CHANNEL_MAIN ,eventData.fMasterVolume);
 		log_debugcpp("Onnanokotify says Reported Channel Qty: " << eventData.nChannels);
 
 		if(multiChannel) 
 			for(UINT i = 0; i < eventData.nChannels; i++) {
-				osh->updateChannelVolumeCallback(this->ep->getIndex(), (uint32_t)i, extraChannelVol[i]);
+				osh->updateVolumeCallback(this->ep->getIndex(), (uint32_t)i, extraChannelVol[i]);
 			}
 		else 
-			osh->updateChannelVolumeCallback(this->ep->getIndex(), (uint32_t)0, pNotify->afChannelVolumes[0]);
+			osh->updateVolumeCallback(this->ep->getIndex(), (uint32_t)0, pNotify->afChannelVolumes[0]);
-		osh->toggleFrontEvents(this->ep->getIndex(), false);
 	}
 	
     return S_OK;

src/cont/contclasses.cpp

@@ -1,5 +1,4 @@
 #include "backlasses.h"
-#include "qtclasses.h"
 #include "contclasses.h"
 //TODO: pragma once
 
@@ -7,8 +6,8 @@
 Overseer OverseerHandler::os;
 
 EndpointHandler::EndpointHandler(uint64_t idx) {
-	std::vector<Endpoint*> endpoints = osh->getPlaybackEndpoints();
+	//std::vector<Endpoint*> endpoints = osh->getPlaybackEndpoints().at(idx);
-	this->ep = endpoints.at(idx);
+	this->ep = osh->getPlaybackEndpoints().at(idx);
 	epc = new EndpointCallback(ep);
 	//epName = ep->getName();
 	ep->setCallback(epc);
@@ -26,7 +25,6 @@ uint64_t EndpointHandler::getIndex(){
 	return idx;
 }
 
-
 /*
  * -1 for master volume
  */
@@ -64,12 +62,6 @@ std::vector<Endpoint*> OverseerHandler::getPlaybackEndpoints() {
 	return this->os.getPlaybackEndpoints();
 }
 
-/*
- * Overseer* OverseerHandler::getOverseer(){
- * 	return &os;
- * }
- */
-
 
 std::vector<EndpointHandler*> OverseerHandler::getEndpointHandlers(){
 	return endpointHandlers;
@@ -108,38 +100,38 @@ void OverseerHandler::setEndpointHandlers(std::vector<EndpointHandler*> ephs){
 	this->endpointHandlers = ephs;
 }
 
+void OverseerHandler::setFrontVolumeCallback(std::function<void(uint64_t, uint32_t, float)> f) {
+	this->updateFrontVolumeCallback = f;
+}
 
-void OverseerHandler::setEndpointWidgets(std::vector<EndpointWidget*> ews){
+void OverseerHandler::setFrontMuteCallback(std::function<void(uint64_t, bool)> f) {
-	this->endpointWidgets = ews;
+	this->updateFrontMuteCallback = f;
 }
 
 void OverseerHandler::updateMuteCallback(uint64_t idx, bool muted){
-	epwMuteFunc f = &EndpointWidget::updateMute;
+	updateFrontMuteCallback(idx, muted);
-	pinvoke_mem_fn(endpointWidgets.at(idx),f)(muted);
-	//std::invoke(f, endpointWidgets.at(idx), muted);
 }
 
-void OverseerHandler::updateMainVolumeCallback(uint64_t idx, float newVal){
+/*
-	//int translatedNewVal = newVal * 100;
+ * void OverseerHandler::updateMainVolumeCallback(uint64_t idx, float newVal){
-	log_debugcpp("mainvolcallback float: " << newVal);
+ * 	
-	epwMainVolumeFunc f = &EndpointWidget::updateMainVolume;
+ * }
-	pinvoke_mem_fn(endpointWidgets.at(idx),f)(newVal);
+ */
-	//std::invoke(f, endpointWidgets.at(idx), newVal);
-}
 
-void OverseerHandler::updateChannelVolumeCallback(uint64_t idx, uint32_t channel, float newVal){
+void OverseerHandler::updateVolumeCallback(uint64_t idx, uint32_t channel, float newVal){
-	//int translatedNewVal = newVal * 100;
+	if (channel == AudioChannel::CHANNEL_MAIN) {
+		log_debugcpp("mainvolcallback float: " << newVal);
+		updateFrontVolumeCallback(idx, AudioChannel::CHANNEL_MAIN, newVal);
+		return;
+	}
+		
+	log_debugcpp("channel: " << channel << " volcallback float: " << newVal);
 
-	log_debugcpp("chanel: " << channel << " volcallback float: " << newVal);
+	// convert channel to bitmask
-	epwChannelVolumeFunc f = &EndpointWidget::updateChannelVolume;
+	uint32_t i = 0;
-	//std::invoke(f, endpointWidgets.at(idx), channel, newVal);
+	while (i < channel)
-	pinvoke_mem_fn(endpointWidgets.at(idx),f)(channel, newVal);
+		i++;
-	//TODO: Soy retrasado
+	uint32_t mask = (1 << i);
-	//endpointWidgets.at(idx)->updateChannelVolume(channel, newVal);
+	
-}
+	updateFrontVolumeCallback(idx, mask, newVal);
-
-void OverseerHandler::toggleFrontEvents(uint64_t idx, bool active) {
-	epwToggleFrontFunc f = &EndpointWidget::toggleFrontEvents;
-	pinvoke_mem_fn(endpointWidgets.at(idx),f)(active);
-		//std::invoke(f, , active);
 }

src/cont/contclasses.h

@@ -9,11 +9,16 @@
 /* #endif */
 
 class EndpointWidget; 
-
 class Endpoint;
 class EndpointCallback;
 class Overseer;
 
+enum AudioChannel {
+	CHANNEL_LEFT  = (1 << 0),
+	CHANNEL_RIGHT = (1 << 1),
+	CHANNEL_MAIN  = ~0,
+};
+
 struct NGuid {
   uint32_t data1;
   uint16_t data2;
@@ -59,21 +64,21 @@ class OverseerHandler {
 public:
 	//OverseerHandler();
 	void setEndpointHandlers(std::vector<EndpointHandler*> ephs);
-	void setEndpointWidgets(std::vector<EndpointWidget*> ews); 
 	std::vector<EndpointHandler*> getEndpointHandlers();
 	std::vector<Endpoint*> getPlaybackEndpoints();
 	uint64_t getPlaybackEndpointsCount();
 	void reloadEndpointHandlers();
 	NGuid* getGuid();
 	void updateMuteCallback(uint64_t idx, bool muted);
-	void updateMainVolumeCallback(uint64_t idx, float newVal);
+	void setFrontMuteCallback(std::function<void(uint64_t, bool)> f);
-	void updateChannelVolumeCallback(uint64_t idx, uint32_t channel, float newVal);
+	void setFrontVolumeCallback(std::function<void(uint64_t, uint32_t, float)> f);
-	void toggleFrontEvents(uint64_t idx, bool active);
+	//void updateMainVolumeCallback(uint64_t idx, float newVal);
-	//void parseExternalEndpointCallback(EndpointCallback *epc, PAUDIO_VOLUME_NOTIFICATION_DATA pNotify);
+	void updateVolumeCallback(uint64_t idx, uint32_t channel, float newVal);
-	//static Overseer* getOverseer();
 	
 private:
     static Overseer os;
 	std::vector<EndpointHandler*> endpointHandlers;
-	std::vector<EndpointWidget*> endpointWidgets; 
+	std::function<void(uint64_t /* device */, uint32_t /* channel */, float /* value */)> updateFrontVolumeCallback;
+	std::function<void(uint64_t /* device */, bool /* mute */)> updateFrontMuteCallback;
+	
 };

src/debug.h

@@ -16,8 +16,14 @@ std::bitset<Y> varToBitset(T info) {
 
 #else 
 #define log_debugcpp(str)
-#define print_as_binary(len, info)
+#define print_as_binary(len, type, info)
 #endif
 
+/* Here as a quick reference, in case smthn similar is needed again */
+/* typedef void (EndpointWidget::*epwMuteFunc)(bool muted); */
+/* typedef void (EndpointWidget::*epwMainVolumeFunc)(float newValue); */
+/* typedef void (EndpointWidget::*epwChannelVolumeFunc)(uint32_t channel, float newValue); */
+/* typedef void (EndpointWidget::*epwToggleFrontFunc)(bool active); */
+
 
 

src/qt/qtclasses.cpp

@@ -73,12 +73,14 @@ EndpointWidget::EndpointWidget(EndpointHandler* eph, QWidget *parent) : QWidget(
 
 void EndpointWidget::updateMute(bool muted){
 	log_debugcpp("cliqui callboqui cloqui");
-	//TODO: Here to diagnose slider visuals locking when playing DJ with external volume bar. Functionality is restored when mute checkbox is clicked.
+	//TIP: Blocksignals here to diagnose slider visuals locking when playing DJ with external volume bar. Functionality is restored when mute checkbox is clicked.
+	//this->blockSignals(true);	
 	//this->muteButton->blockSignals(true);
 	//this->eph->setMute(osh->getGuid(), muted);
-	this->muteButton->setChecked(eph->getMute() ? true : false);
+	this->muteButton->setChecked(muted);
 	this->muteButton->setText(this->eph->getMute() ? STRING_UNMUTE : STRING_MUTE);
 	//this->muteButton->blockSignals(false);
+	//this->blockSignals(false);	
 }
 
 void EndpointWidget::updateMute(int checked){
@@ -96,35 +98,49 @@ void EndpointWidget::updateMainVolume(int newValue){
 }
 
 void EndpointWidget::updateMainVolume(float newValue){
+	//this->blockSignals(true);	
 	int newVal = newValue * 100;
 	log_debugcpp("mainvolcallback int: " << newVal);
 	//this->mainSlider->blockSignals(true);
-	//TODO: Above
+	
 	if(this->mainSlider->value() != newVal) {
 		this->mainSlider->setValue(newVal);
 	}
 	//this->mainSlider->blockSignals(false);
+	//this->blockSignals(false);
 }
 
 void EndpointWidget::updateChannelVolume(uint32_t channel, float newValue){
+	//this->blockSignals(true);
+	if (channel == (uint32_t)AudioChannel::CHANNEL_MAIN) 
+		updateMainVolume(newValue);
+		
 	int newVal = newValue * 100;
 	log_debugcpp("chanel: " << channel << " volcallback int: " << newVal);
-	//TODO: Above
+
-	//this->channelSliders.at(channel)->blockSignals(true);
+	for (size_t i = 0; i < sizeof(uint32_t) * 8 && i < channelSliders.size(); ++i) {
-	if(this->channelSliders.at(channel)->value() != newVal) {
+		if (((channel >> i) & 1) && this->channelSliders.at(i)->value() != newVal) {
-		this->channelSliders.at(channel)->setValue(newVal);
+			//this->channelSliders.at(i)->blockSignals(true);
-		this->channelLabels.at(channel)->setText(QString::number((int)(newValue * 100)));
+			
+			this->channelSliders.at(i)->setValue(newVal);
+			this->channelLabels.at(i)->setText(QString::number((int)(newValue * 100)));
+			
+			//this->channelSliders.at(i)->blockSignals(false);
+		}
 	}
-	//this->channelSliders.at(channel)->blockSignals(false);
+
+	//this->blockSignals(false);
 }
 
-void EndpointWidget::toggleFrontEvents(bool active){
+/*
-	this->muteButton->blockSignals(active);
+ * void EndpointWidget::toggleFrontEvents(bool active){
-	this->mainSlider->blockSignals(active);
+ * 	this->muteButton->blockSignals(active);
-	for(uint32_t i = 0; i < this->channelSliders.size(); i++){
+ * 	this->mainSlider->blockSignals(active);
-		this->channelSliders.at(i)->blockSignals(active);
+ * 	for(uint32_t i = 0; i < this->channelSliders.size(); i++){
-	}
+ * 		this->channelSliders.at(i)->blockSignals(active);
-}
+ * 	}
+ * }
+ */
 
 
 void EndpointWidget::setIndex(uint64_t idx){
@@ -158,11 +174,18 @@ void MainWindow::reloadEndpointWidgets() {
 		ews.push_back(epw);
 		layout->addWidget(epw, i, 0);
 	}
-	osh->setEndpointWidgets(ews);
-	layout->addItem(new QSpacerItem(1, 1, QSizePolicy::Minimum, QSizePolicy::MinimumExpanding), i, 0);
-}
 
-//#include "qtclosemwh.h"
+	layout->addItem(new QSpacerItem(1, 1, QSizePolicy::Minimum, QSizePolicy::MinimumExpanding), i, 0);
+	
+	osh->setFrontVolumeCallback([this](uint64_t device, uint32_t channel, float value) {
+		if (device < ews.size())
+			ews[device]->updateChannelVolume(channel, value);
+	});
+	osh->setFrontMuteCallback([this](uint64_t device, bool muted) {
+		if (device < ews.size())
+			ews[device]->updateMute(muted);
+	});
+}
 
 /*
    * void MainWindow::setPlotButton() {

src/qt/qtclasses.h

@@ -71,7 +71,7 @@ public:
 	void updateMainVolume(float newValue);
 	void updateChannelVolume(uint32_t channel, float newValue);
 	void updateMute(bool muted);
-	void toggleFrontEvents(bool active);
+	//void toggleFrontEvents(bool active);
 	
 	//void populateEndpointWidget(EndpointHandler *eph);
 	//void setEndpointHandlers(std::vector<EndpointHandler*> *ephs);
@@ -84,18 +84,12 @@ private:
 	uint64_t idx;
 	//std::vector<EndpointHandler*> *ephs;
 	//std::vector<QSlider> *sliders;
-
 	
 	//signals:
     //void valueChanged(int value);
 
 };
 
-typedef void (EndpointWidget::*epwMuteFunc)(bool muted);
-typedef void (EndpointWidget::*epwMainVolumeFunc)(float newValue);
-typedef void (EndpointWidget::*epwChannelVolumeFunc)(uint32_t channel, float newValue);
-typedef void (EndpointWidget::*epwToggleFrontFunc)(bool active);
-
 class MainWindow : public QMainWindow {
 	Q_OBJECT
 	//QWidget *centralWidget;
@@ -103,6 +97,7 @@ class MainWindow : public QMainWindow {
 public:
 	MainWindow(QWidget *parent = nullptr);
 	void reloadEndpointWidgets();
+
 	//TODO: destroy/empty existing EndpointWidgets
 	//void setEndpointHandlers(std::vector<EndpointHandler*> *ephs);