403 lines
15 KiB
C++
403 lines
15 KiB
C++
#include "qtclasses.h"
|
|
|
|
EndpointWidgetEvent::EndpointWidgetEvent(QEvent::Type type, int idx) : QEvent(type){
|
|
this->idx = idx;
|
|
}
|
|
|
|
bool ExtendedCheckBox::event(QEvent* ev) {
|
|
if (ev->type() == QEvent::User) {
|
|
//todo: still prone to bugs; whack-a-mole to come
|
|
this->blockSignals(true);
|
|
if (this->isEnabled()) {
|
|
this->setCheckState(Qt::Checked);
|
|
this->setDisabled(true);
|
|
} else {
|
|
this->setDisabled(false);
|
|
this->setCheckState(Qt::Unchecked);
|
|
}
|
|
this->blockSignals(false);
|
|
return true;
|
|
}
|
|
// Make sure the rest of events are handled
|
|
return QCheckBox::event(ev);
|
|
}
|
|
|
|
EndpointWidget::EndpointWidget(uint64_t idx, EndpointHandler* eph, QWidget *parent) : QWidget(parent){
|
|
//todo: based on qgridlayout, name+mute should be its own widget, same with channels
|
|
this->idx = idx;
|
|
this->eph = eph;
|
|
this->eph->setFrontVisibilityInfo(EndpointState::ENDPOINT_ACTIVE, idx);
|
|
layout = new QGridLayout(this);
|
|
//this->setLayout(layout);
|
|
log_debugcpp("epw main layout parent: "<< layout->parent());
|
|
if (parent == nullptr) { log_debugcpp("owo?"); }
|
|
|
|
defaultRolesCheckBoxes = {
|
|
{Roles::ROLE_ALL, new ExtendedCheckBox(this)},
|
|
{Roles::ROLE_CONSOLE, new ExtendedCheckBox(this)},
|
|
{Roles::ROLE_MULTIMEDIA, new ExtendedCheckBox(this)},
|
|
{Roles::ROLE_COMMUNICATIONS, new ExtendedCheckBox(this)}
|
|
};
|
|
|
|
/*
|
|
* Mute, main slider and label setup
|
|
*/
|
|
muteButton = new QCheckBox(this);
|
|
mainLabel = new QLabel(QString::fromStdWString(eph->getName()), this);
|
|
mainSlider = new QSlider(Qt::Horizontal, this);
|
|
|
|
if (this->eph->getState() != EndpointState::ENDPOINT_ACTIVE) {
|
|
layout->addWidget(mainLabel, 0, 0);
|
|
layout->addItem(new QSpacerItem(1, 1, QSizePolicy::Minimum, QSizePolicy::Minimum), 1, 0);
|
|
return;
|
|
}
|
|
|
|
//muteButton->setStyleSheet("background-color: #A3C1DA; color: red");
|
|
mainSlider->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
|
|
mainSlider->setFocusPolicy(Qt::StrongFocus);
|
|
mainSlider->setTickPosition(QSlider::TicksBothSides);
|
|
mainSlider->setTickInterval(5);
|
|
mainSlider->setSingleStep(1);
|
|
mainSlider->setRange(0,100);
|
|
|
|
muteButton->setCheckState((eph->getMute() == false ? Qt::Unchecked : Qt::Checked));
|
|
muteButton->setText(eph->getMute() ? STRING_UNMUTE : STRING_MUTE);
|
|
float volume = eph->getVolume(AudioChannel::CHANNEL_MAIN) * 100;
|
|
mainSlider->setValue((int)volume);
|
|
log_debugcpp("ENDPOINT SET WITH VOLUME " << volume);
|
|
|
|
//tip: would need to be new widget with layout in it
|
|
//mainMuteLayout = new QGridLayout();
|
|
layout->addWidget(mainLabel, 0, 0, Qt::AlignLeft | Qt::AlignBottom);
|
|
layout->addWidget(muteButton, 0, 1, Qt::AlignLeft | Qt::AlignBottom);
|
|
layout->addWidget(mainSlider, 0, 2, 1, 2);
|
|
|
|
//TODO:0 = mute and muted, change volume = unmuted are client side tricks = 2 callbacks, one for volume, one for mute state. Implement as an user selectable option?
|
|
connect<void(QSlider::*)(int), void(EndpointWidget::*)(int)>(mainSlider, &QSlider::valueChanged, this,&EndpointWidget::updateMainVolume);
|
|
connect<void(QCheckBox::*)(int), void(EndpointWidget::*)(int)>(muteButton, &QCheckBox::stateChanged, this, (&EndpointWidget::updateMute));
|
|
|
|
|
|
/*
|
|
* Channel sliders setup
|
|
*/
|
|
for(uint32_t i = 0; i < eph->getChannelCount(); i++){
|
|
QSlider* tmp = new QSlider(Qt::Horizontal);
|
|
QLabel* tmpLb = new QLabel("");
|
|
tmp->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
|
|
tmp->setTickInterval(5);
|
|
tmp->setSingleStep(1);
|
|
tmp->setRange(0,100);
|
|
|
|
volume = eph->getVolume(i) * 100;
|
|
tmp->setValue((int) volume);
|
|
tmpLb->setText(QString::number(volume));
|
|
this->channelSliders.push_back(tmp);
|
|
this->channelLabels.push_back(tmpLb);
|
|
layout->addWidget(tmp, 2, i);
|
|
layout->addWidget(tmpLb, 3, i);
|
|
//TODO: check if there's a need to prevent deadlocks; probably this will eventually turn into its own func
|
|
//this causes channel bar desync when back -> front. blocksignals below fix it. huh.
|
|
connect(tmp, &QSlider::valueChanged, [this, i](int newValue){
|
|
this->eph->setVolume(osh->getGuid(), i, newValue);
|
|
this->channelLabels.at(i)->setText(QString::number(newValue));
|
|
});
|
|
}
|
|
|
|
/*
|
|
* Role ExtendedCheckBoxes setup
|
|
*/
|
|
|
|
uint8_t assignedRoles = eph->getRoles();
|
|
defaultRolesCheckBoxes.at(Roles::ROLE_ALL)->setCheckState(assignedRoles == Roles::ROLE_ALL ? Qt::Checked : Qt::Unchecked);
|
|
//todo duditas de &
|
|
defaultRolesCheckBoxes.at(Roles::ROLE_ALL)->setDisabled(assignedRoles == Roles::ROLE_ALL ? true : false);
|
|
defaultRolesCheckBoxes.at(Roles::ROLE_ALL)->setText(STRING_ROLE_ALL);
|
|
|
|
defaultRolesCheckBoxes.at(Roles::ROLE_CONSOLE)->setCheckState(assignedRoles & Roles::ROLE_CONSOLE ? Qt::Checked : Qt::Unchecked);
|
|
defaultRolesCheckBoxes.at(Roles::ROLE_CONSOLE)->setDisabled(assignedRoles & Roles::ROLE_CONSOLE ? true : false);
|
|
defaultRolesCheckBoxes.at(Roles::ROLE_CONSOLE)->setText(STRING_ROLE_CONSOLE);
|
|
|
|
defaultRolesCheckBoxes.at(Roles::ROLE_MULTIMEDIA)->setCheckState(assignedRoles & Roles::ROLE_MULTIMEDIA ? Qt::Checked : Qt::Unchecked);
|
|
defaultRolesCheckBoxes.at(Roles::ROLE_MULTIMEDIA)->setDisabled(assignedRoles & Roles::ROLE_MULTIMEDIA ? true : false);
|
|
defaultRolesCheckBoxes.at(Roles::ROLE_MULTIMEDIA)->setText(STRING_ROLE_MULTIMEDIA);
|
|
|
|
defaultRolesCheckBoxes.at(Roles::ROLE_COMMUNICATIONS)->setCheckState(assignedRoles & Roles::ROLE_COMMUNICATIONS ? Qt::Checked : Qt::Unchecked);
|
|
defaultRolesCheckBoxes.at(Roles::ROLE_COMMUNICATIONS)->setDisabled(assignedRoles & Roles::ROLE_COMMUNICATIONS ? true : false);
|
|
defaultRolesCheckBoxes.at(Roles::ROLE_COMMUNICATIONS)->setText(STRING_ROLE_COMMUNICATIONS);
|
|
|
|
connect(defaultRolesCheckBoxes.at(Roles::ROLE_ALL), &QCheckBox::stateChanged,[this] {
|
|
this->eph->setRoles(Roles::ROLE_ALL);
|
|
});
|
|
connect(defaultRolesCheckBoxes.at(Roles::ROLE_CONSOLE), &QCheckBox::stateChanged,[this] {
|
|
this->eph->setRoles(Roles::ROLE_CONSOLE);
|
|
});
|
|
connect(defaultRolesCheckBoxes.at(Roles::ROLE_MULTIMEDIA), &QCheckBox::stateChanged,[this] {
|
|
this->eph->setRoles(Roles::ROLE_MULTIMEDIA);
|
|
});
|
|
|
|
connect(defaultRolesCheckBoxes.at(Roles::ROLE_COMMUNICATIONS), &QCheckBox::stateChanged,[this] {
|
|
this->eph->setRoles(Roles::ROLE_COMMUNICATIONS);
|
|
});
|
|
|
|
layout->addWidget(defaultRolesCheckBoxes.at(Roles::ROLE_ALL), 5, 0);
|
|
layout->addWidget(defaultRolesCheckBoxes.at(Roles::ROLE_CONSOLE), 5, 1);
|
|
layout->addWidget(defaultRolesCheckBoxes.at(Roles::ROLE_MULTIMEDIA), 5, 2);
|
|
layout->addWidget(defaultRolesCheckBoxes.at(Roles::ROLE_COMMUNICATIONS), 5, 3);
|
|
|
|
/* ----------------------------------------------------------- */
|
|
|
|
/*
|
|
* EndpointVolume Polling time
|
|
*/
|
|
timer = new QTimer();
|
|
connect(timer, &QTimer::timeout, [this, eph](){
|
|
//if (memcmp(osh->callbackInfo[idx]->caller, osh->getGuid(), sizeof(NGuid)) == 0) return; CHECK IF THIS PROGRAM GENERATED THE FUNSIES IS NO LONGER IN USE FOR NOW.
|
|
const float roundingFactor = 0.005;
|
|
mainSlider->blockSignals(true);
|
|
muteButton->blockSignals(true);
|
|
mainSlider->setValue((int)((eph->getCallbackInfo()->mainVolume + roundingFactor) * 100));
|
|
muteButton->setCheckState((eph->getCallbackInfo()->muted == false ? Qt::Unchecked : Qt::Checked));
|
|
muteButton->setText(eph->getCallbackInfo()->muted ? STRING_UNMUTE : STRING_MUTE);
|
|
for(uint32_t i = 0; i < eph->getCallbackInfo()->channels; i++){
|
|
this->channelSliders.at(i)->blockSignals(true);
|
|
this->channelSliders.at(i)->setValue((int)((eph->getCallbackInfo()->channelVolumes[i] + roundingFactor) * 100));
|
|
this->channelLabels.at(i)->setText(QString::number((int)((eph->getCallbackInfo()->channelVolumes[i] + roundingFactor) * 100)));
|
|
this->channelSliders.at(i)->blockSignals(false);
|
|
}
|
|
//memcpy(osh->callbackInfo[idx]->caller, osh->getGuid(), sizeof(NGuid));
|
|
|
|
//TODO: el default = objcopy frees?
|
|
eph->getCallbackInfo()->caller = osh->getGuid();
|
|
mainSlider->blockSignals(false);
|
|
muteButton->blockSignals(false);
|
|
});
|
|
timer->start(10);
|
|
|
|
//todo parent?
|
|
layout->addItem(new QSpacerItem(1, 1, QSizePolicy::Minimum, QSizePolicy::Minimum), 1, 0);
|
|
layout->addItem(new QSpacerItem(1, 1, QSizePolicy::Minimum, QSizePolicy::Minimum), 4, 0);
|
|
layout->addItem(new QSpacerItem(1, 1, QSizePolicy::Minimum, QSizePolicy::MinimumExpanding), 6, 0);
|
|
layout->addItem(new QSpacerItem(1, 1, QSizePolicy::Minimum, QSizePolicy::MinimumExpanding), 6, 1);
|
|
log_debugcpp("ENDPOINT_WIDGETED");
|
|
}
|
|
|
|
void MainWindow::customEvent(QEvent* ev) {
|
|
if (ev->type() == (QEvent::Type)CustomQEvent::EndpointWidgetObsolete) {
|
|
this->removeEndpointWidget((EndpointWidgetEvent*)ev);
|
|
return;
|
|
}
|
|
// Make sure the rest of events are handled
|
|
return QMainWindow::customEvent(ev);
|
|
}
|
|
|
|
void MainWindow::removeEndpointWidget(EndpointWidgetEvent* ev){
|
|
uint64_t i = ev->idx;
|
|
this->ews.at(i)->setParent(nullptr);
|
|
this->layout->removeWidget(ews.at(i));
|
|
uint64_t saisu = ews.size();
|
|
//delete ews.at(index);
|
|
while ((i + 1) < ews.size()) {
|
|
ews.at(i) = ews.at(i + 1);
|
|
ews.at(i)->updateEndpointHandlerFrontInfo(i);
|
|
i++;
|
|
}
|
|
ews.pop_back();
|
|
return;
|
|
}
|
|
|
|
|
|
void EndpointWidget::updateMute(int checked){
|
|
bool muted = (checked == 2 ? true : false);
|
|
this->eph->setMute(osh->getGuid(), muted);
|
|
this->muteButton->setText(this->eph->getMute() ? STRING_UNMUTE : STRING_MUTE);
|
|
}
|
|
|
|
void EndpointWidget::updateMainVolume(int newValue){
|
|
this->eph->setVolume(osh->getGuid(), AudioChannel::CHANNEL_MAIN, newValue);
|
|
}
|
|
|
|
/*
|
|
* void EndpointWidget::updateVolume(uint32_t channel, float newValue){
|
|
* //this->blockSignals(true);
|
|
* int newVal = newValue * 100;
|
|
* if (channel == (uint32_t)AudioChannel::CHANNEL_MAIN) {
|
|
* //TIP: Above
|
|
* //this->mainSlider->blockSignals(true);
|
|
*
|
|
* if(this->mainSlider->value() != newVal) {
|
|
* this->mainSlider->blockSignals(true);
|
|
* this->mainSlider->setValue(newVal);
|
|
* this->mainSlider->blockSignals(false);
|
|
* }
|
|
* return;
|
|
* }
|
|
*
|
|
* for (size_t i = 0; i < sizeof(uint32_t) * 8 && i < channelSliders.size(); ++i) {
|
|
* if (((channel >> i) & 1) && this->channelSliders.at(i)->value() != newVal) {
|
|
* //this->channelSliders.at(i)->blockSignals(true);
|
|
*
|
|
* this->channelSliders.at(i)->setValue(newVal);
|
|
* this->channelLabels.at(i)->setText(QString::number((int)(newValue * 100)));
|
|
*
|
|
* //this->channelSliders.at(i)->blockSignals(false);
|
|
* }
|
|
* }
|
|
*
|
|
* //this->blockSignals(false);
|
|
* }
|
|
*/
|
|
|
|
EndpointHandler* EndpointWidget::getEndpointHandler(){
|
|
return this->eph;
|
|
}
|
|
|
|
void EndpointWidget::updateEndpointHandlerFrontInfo(uint64_t index){
|
|
this->eph->setFrontVisibilityInfo(EndpointState::ENDPOINT_ACTIVE, index);
|
|
}
|
|
|
|
|
|
void EndpointWidget::setIndex(uint64_t idx){
|
|
this->idx = idx;
|
|
}
|
|
|
|
uint64_t EndpointWidget::getIndex(){
|
|
return idx;
|
|
}
|
|
|
|
MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent) {
|
|
// setWindowState(Qt::WindowFullScreen);
|
|
// setCentralWidget(centralWidget);
|
|
|
|
/*
|
|
* Registering needed custom events
|
|
*/
|
|
QEvent::registerEventType(CustomQEvent::EndpointWidgetObsolete);
|
|
|
|
widget = new QWidget();
|
|
layout = new QGridLayout();
|
|
trayIcon = new QSystemTrayIcon();
|
|
trayIconMenu = new QMenu();
|
|
trayIconMenuQuit = new QAction(STRING_QUIT);
|
|
|
|
changeDefaultCheckboxEnablement = new QEvent(QEvent::User);
|
|
changeDefaultCheckboxEnablement->setAccepted(true);
|
|
|
|
widget->setLayout(layout);
|
|
setCentralWidget(widget);
|
|
//layout->addWidget(pintas, 0, 0);
|
|
setWindowTitle(STRING_TITLE);
|
|
|
|
reloadEndpointWidgets();
|
|
|
|
/*
|
|
* Tray Icon code
|
|
*/
|
|
trayIconMenu->addSeparator();
|
|
trayIconMenu->addAction(trayIconMenuQuit);
|
|
connect(trayIconMenuQuit, &QAction::triggered, qApp, &QCoreApplication::quit);
|
|
trayIcon->setIcon(QIcon(":/assets/notificationAreaIcon.png"));
|
|
setWindowIcon(QIcon(":/assets/notificationAreaIcon.png"));
|
|
//TODO: Extend qsystemtrayicon to change mouse click?
|
|
//show before setting tooltip required; smells like bug to me!
|
|
trayIcon->show();
|
|
trayIcon->setToolTip(STRING_TITLE);
|
|
trayIcon->setContextMenu(trayIconMenu);
|
|
connect(trayIcon, &QSystemTrayIcon::activated, this, &MainWindow::trayIconActivated);
|
|
|
|
/*
|
|
* Set of function callback definitons for EndpointSituationCallback
|
|
*/
|
|
osh->setChangeFrontDefaultsFunction([this](Roles role, std::wstring endpointId) {
|
|
for (auto epw : this->ews) {
|
|
/*
|
|
* Is this the new default endpoint?
|
|
*/
|
|
if (epw->getEndpointHandler()->getId() == endpointId) {
|
|
//not necessary to keep endpointState flags up to date right now, but updating it will allow for later config files / profiles
|
|
epw->defaultRolesCheckBoxes.at(role)->blockSignals(true);
|
|
epw->getEndpointHandler()->assignRoles(role);
|
|
epw->defaultRolesCheckBoxes.at(role)->blockSignals(false);
|
|
QCoreApplication::instance()->postEvent(epw->defaultRolesCheckBoxes.at(role), changeDefaultCheckboxEnablement);
|
|
//epw->defaultRolesCheckBoxes.at(role)->postEnableChange();
|
|
/*
|
|
* And were you THE default?
|
|
*/
|
|
if (epw->getEndpointHandler()->getRoles() == Roles::ROLE_ALL) {
|
|
QCoreApplication::instance()->postEvent(epw->defaultRolesCheckBoxes.at(Roles::ROLE_ALL), changeDefaultCheckboxEnablement);
|
|
}
|
|
/*
|
|
* Are you the dethroned king?
|
|
*/
|
|
} else if (epw->getEndpointHandler()->getRoles() & role) {
|
|
/*
|
|
* And were you THE default up until now?
|
|
*/
|
|
if (epw->getEndpointHandler()->getRoles() == Roles::ROLE_ALL) {
|
|
QCoreApplication::instance()->postEvent(epw->defaultRolesCheckBoxes.at(Roles::ROLE_ALL), changeDefaultCheckboxEnablement);
|
|
}
|
|
|
|
epw->defaultRolesCheckBoxes.at(role)->blockSignals(true);
|
|
//Same as before. ini-san will come...
|
|
epw->getEndpointHandler()->removeRoles(role);
|
|
epw->defaultRolesCheckBoxes.at(role)->blockSignals(false);
|
|
QCoreApplication::instance()->postEvent(epw->defaultRolesCheckBoxes.at(role), changeDefaultCheckboxEnablement);
|
|
|
|
}
|
|
}
|
|
});
|
|
|
|
osh->setRemoveEndpointWidgetFunction([this](uint64_t index) {
|
|
EndpointWidgetEvent removeObsoleteEndpointWidget((QEvent::Type)CustomQEvent::EndpointWidgetObsolete, index);
|
|
removeObsoleteEndpointWidget.setAccepted(true);
|
|
QCoreApplication::instance()->postEvent(this, &removeObsoleteEndpointWidget);
|
|
});
|
|
|
|
/*
|
|
* osh->setReviseEndpointShowingFunction([this](std::wstring endpointId, Roles role){
|
|
*
|
|
*
|
|
* });
|
|
*/
|
|
|
|
}
|
|
|
|
|
|
void MainWindow::closeEvent(QCloseEvent *event) {
|
|
if (!event->spontaneous() || !isVisible()) return;
|
|
|
|
if (trayIcon->isVisible()) {
|
|
//todo: would be nice to show this to 1st time users; ini-san will come...
|
|
//this->trayIcon->showMessage("ini file calling","tratarte como un gilipollas la primera vez", QSystemTrayIcon::Information);
|
|
|
|
hide();
|
|
event->ignore();
|
|
}
|
|
}
|
|
|
|
void MainWindow::trayIconActivated(QSystemTrayIcon::ActivationReason reason) {
|
|
switch (reason) {
|
|
case QSystemTrayIcon::Trigger:
|
|
this->showNormal();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void MainWindow::reloadEndpointWidgets() {
|
|
size_t i = 0;
|
|
for (size_t epwIndex = 0; i < (osh->getEndpointHandlers().size()); i++) {
|
|
if (osh->getEndpointHandlers().at(i)->getState() == EndpointState::ENDPOINT_ACTIVE){
|
|
log_debugcpp("EPWidget creation");
|
|
osh->getEndpointHandlers().at(i)->getCallbackInfo()->caller = osh->getGuid();
|
|
EndpointWidget *epw = new EndpointWidget(epwIndex, osh->getEndpointHandlers().at(i), widget);
|
|
epwIndex++;
|
|
//alfinal estoes solopara inicializarlmao
|
|
ews.push_back(epw);
|
|
layout->addWidget(epw, i, 0);
|
|
}
|
|
}
|
|
//todo:: tas aqui tirao, no me gustas y probablemente yo a ti tampoco
|
|
layout->addItem(new QSpacerItem(1, 1, QSizePolicy::Minimum, QSizePolicy::MinimumExpanding), i, 0);
|
|
}
|
|
|