wip: icons

fixed synch issues + memleak @ name fetching
fixed visuals when adding epw/sw while window is visible
2026-01-31 18:09:02 +01:00 · 2025-01-25 17:27:36 +01:00 · 2025-01-18 18:51:32 +01:00 · 2025-01-18 18:01:35 +01:00 · 2025-01-16 22:13:41 +01:00 · 2025-01-16 20:29:02 +01:00
30 changed files with 3473 additions and 671 deletions
--- a/.gitignore
+++ b/.gitignore
@ -2,6 +2,7 @@ build
 *.rdbg
 *.pdb
 *.ps1
+*.exe
 Makefile
 Makefile.Debug
 Makefile.Release
--- a/assets.qrc
+++ b/assets.qrc
@ -1,7 +1,10 @@
 <!DOCTYPE RCC><RCC version="1.0">
 <qresource prefix="/">
+  <file>assets/selawk.ttf</file>
  <file>assets/notificationAreaIcon.png</file>
  <file>assets/style.qss</file>
  <file>assets/logo.ico</file>
+  <file>assets/mute.svg</file>
+  <file>assets/unmute.svg</file>
 </qresource>
 </RCC>
--- a/assets/SoundVolumeView.exe
+++ b/assets/SoundVolumeView.exe
--- a/assets/installer.ico
+++ b/assets/installer.ico
--- a/assets/installer.xcf
+++ b/assets/installer.xcf
--- a/assets/selawk.ttf
+++ b/assets/selawk.ttf
--- a/assets/uninstaller.ico
+++ b/assets/uninstaller.ico
--- a/bueno.bat
+++ b/bueno.bat
@ -1,5 +1,7 @@
-taskkill /F /IM "qtest.exe"
-qmake -o build\Makefile .\qtest.pro
-copy /Y /B .\assets\SoundVolumeView.exe .\build\debug
-copy /Y /B .\assets\SoundVolumeView.exe .\build\release
-mingw32-make.exe -C .\build -f Makefile
+taskkill /F /IM "MixerQ.exe"
+taskkill /F /IM "MixerQd.exe"
+qmake -o build\Makefile .\qtest.pro 
+REM mingw32-make.exe -C .\build -f Makefile.Release
+mingw32-make.exe -C .\build -f Makefile.Debug
+REM makensis /DBUILDTYPE=release install\installer.nsi
+REM makensis /DBUILDTYPE=debug install\installer.nsi
--- a/install/installer.nsi
+++ b/install/installer.nsi
@ -0,0 +1,265 @@
+;Auto versioning-------------------------------
+
+  !makensis "/DBUILDTYPE=${BUILDTYPE} version.nsi"
+  !system "GetVersion.exe"
+  !include "Version.txt"
+  ;optional cleanup
+  !delfile "GetVersion.exe"
+  !delfile "Version.txt"
+
+;Includes--------------------------------
+
+  !include "MUI2.nsh"
+  !include "nsDialogs.nsh"
+  !include "LogicLib.nsh"
+  !include "${NSISDIR}\Contrib\Language files\English.nsh"
+  !include "${NSISDIR}\Contrib\Language files\Spanish.nsh"
+  ;!include "${NSISDIR}\Contrib\Language files\English.nsh"
+  
+
+;Defines----------------------------------
+  !define MUI_LANGDLL_ALLLANGUAGES
+  !define MUI_UNICON "..\assets\uninstaller.ico"
+  !define MUI_ICON "..\assets\installer.ico"
+  
+
+;--------------------------------
+;General
+
+  ;Name and file
+  !if ${BUILDTYPE} == "release"
+    Name "MixerQ"
+  !else
+    Name "MixerQd"
+  !endif
+  OutFile "..\build\bin\MixerQ-installer-${version}.exe" 
+  
+  ;Get installation folder from registry if available
+  ;InstallDirRegKey HKCU "Software\Modern UI Test" ""
+  
+  Unicode True
+  Var Is_Admin
+  Var Install_Type
+
+  ;Request application privileges for UAC. If admin is not available, only user-level install will be available
+  RequestExecutionLevel highest
+;--------------------------------
+;Interface Settings
+
+  !define MUI_ABORTWARNING
+
+;--------------------------------
+;Pages
+  !insertmacro MUI_PAGE_WELCOME
+  !insertmacro MUI_PAGE_LICENSE "..\LICENSE.txt"
+  ;!insertmacro MULTIUSER_PAGE_INSTALLMODE
+  Page Custom InstallTargetPage
+  ;!insertmacro MUI_PAGE_COMPONENTS
+  !define MUI_PAGE_CUSTOMFUNCTION_PRE Skip_Directory_Func
+  !insertmacro MUI_PAGE_DIRECTORY 
+  !insertmacro MUI_PAGE_INSTFILES
+  !insertmacro MUI_PAGE_FINISH
+
+  !insertmacro MUI_UNPAGE_WELCOME
+  !insertmacro MUI_UNPAGE_CONFIRM
+  !insertmacro MUI_UNPAGE_INSTFILES
+  !insertmacro MUI_UNPAGE_FINISH
+
+;--------------------------------
+;Languages
+
+  !insertmacro MUI_LANGUAGE "English"
+  !insertmacro MUI_LANGUAGE "Spanish"
+  !insertmacro MUI_LANGUAGE "SpanishInternational"
+
+  ;English----------------------------
+  LangString Header_Title    ${LANG_ENGLISH} "Configure Install"
+  LangString Header_Subtitle ${LANG_ENGLISH} "Customize install settings"
+  LangString Option_Scope    ${LANG_ENGLISH} "Select for whom will $(^Name) be installed: "
+  LangString Scope_Machine   ${LANG_ENGLISH} "All users"
+  LangString Scope_User      ${LANG_ENGLISH} "Current user"
+  
+  ;Spanish/SpanishInternational----------------------------
+  LangString Header_Title    ${LANG_SPANISH} "Configurar instalación"
+  LangString Header_Subtitle ${LANG_SPANISH} "Elija los ajustes de la instalación"
+  LangString Option_Scope    ${LANG_SPANISH} "$(^Name) será instalado para: "
+  LangString Scope_Machine   ${LANG_SPANISH} "Todos los usuarios"
+  LangString Scope_User      ${LANG_SPANISH} "Usuario actual"
+  
+  LangString Header_Title    ${LANG_SPANISHINTERNATIONAL} "Configurar instalación"
+  LangString Header_Subtitle ${LANG_SPANISHINTERNATIONAL} "Elija los ajustes de la instalación"
+  LangString Option_Scope    ${LANG_SPANISHINTERNATIONAL} "$(^Name) será instalado para: "
+  LangString Scope_Machine   ${LANG_SPANISHINTERNATIONAL} "Todos los usuarios"
+  LangString Scope_User      ${LANG_SPANISHINTERNATIONAL} "Usuario actual"
+  
+;Functions------------------------------
+  Function Skip_Directory_Func
+    ;StrCmp $Install_Type "user" dontSkip
+    Abort # skip the page
+  ;dontSkip:
+    FunctionEnd
+
+  !macro ONINIT un
+  		 Function ${un}.onInit
+	        ; The value of SetShellVarContext detetmines whether SHCTX is HKLM or HKCU
+	        ; and whether SMPROGRAMS refers to all users or just the current
+			!insertmacro MUI_LANGDLL_DISPLAY
+	        UserInfo::GetAccountType
+	        Pop $0
+	        ${If} $0 == "Admin"
+	            ; If we're an admin, default to installing to C:\Program Files
+	            SetShellVarContext all
+	            ; StrCpy $INSTDIR "$PROGRAMFILES64\$(^Name)"
+				StrCpy $Is_Admin "true"
+	        ${Else}
+	            ; If we're just a user, default to installing to ~\AppData\Local
+	            SetShellVarContext current
+	            ; StrCpy $INSTDIR "$LOCALAPPDATA\$(^Name)"
+				StrCpy $Is_Admin "false"
+	        ${EndIf}
+	
+	        ; ${If} $INSTDIR == ""
+	        ;     ; This only happens in the installer, because the uninstaller already knows INSTDIR
+	        ;     ReadRegStr $0 SHCTX "Software\${PRODUCT_NAME}" ""
+	
+	        ;     ${If} $0 != ""
+	        ;         ; If we're already installed, use the existing directory
+	        ;         StrCpy $INSTDIR "$0"
+	        ;     ${Else}
+	        ;         StrCpy $INSTDIR "$INSTDIR_BASE\${PRODUCT_NAME}"
+	        ;     ${Endif}
+	        ; ${Endif}
+	    FunctionEnd
+	!macroend
+
+!insertmacro ONINIT ""
+!insertmacro ONINIT "un"
+
+;NSDialog InstallTarget Page definition---------------------------------
+
+Function InstallTargetPage
+   !insertmacro MUI_HEADER_TEXT $(Header_Title) $(Header_Subtitle)
+    ;MessageBox MB_OK "Install type $Install_Type"
+	;MessageBox MB_OK "Build type ${BUILDTYPE}"
+	nsDialogs::Create 1018
+	Pop $0
+
+	FindWindow $0 "#32770"
+    GetDlgItem $1 $0 1 ;next/install button
+    SendMessage $1 ${WM_SETTEXT} 1 "STR:$(^InstallBtn)"
+	Pop $0
+
+	${NSD_CreateLabel} 0 0 100% 10% $(Option_Scope)
+    Pop $3
+	
+	${NSD_CreateFirstRadioButton} 0 12% 40% 6% $(Scope_Machine)
+	Pop $1
+	${If} $Is_Admin == "false"
+		EnableWindow $1 0
+		StrCpy $INSTDIR "$LOCALAPPDATA\$(^Name)"
+	${Else}
+		SendMessage $1 ${BM_CLICK} "" "" ;Set default
+		StrCpy $INSTDIR "$PROGRAMFILES64\$(^Name)"
+	${EndIf}
+	${NSD_OnClick} $1 All_Users_Click
+
+	${NSD_CreateAdditionalRadioButton} 0 24% 40% 6% $(Scope_User)
+	Pop $2
+	${IfThen} $Is_Admin == "false" ${|} SendMessage $2 ${BM_CLICK} "" "" ${|}
+	${NSD_OnClick} $2 Current_User_Click
+	
+	nsDialogs::Show
+FunctionEnd
+
+Function All_Users_Click
+	Pop $0
+	SetShellVarContext all
+    StrCpy $INSTDIR "$PROGRAMFILES64\$(^Name)"
+	StrCpy $Install_Type "machine"
+	;${NSD_SetText} $0 "machine"
+	;FindWindow $0 "#32770"
+    ;GetDlgItem $1 $0 1 ;next/install button
+    ;SendMessage $1 ${WM_SETTEXT} 1 "STR:$(^InstallBtn)"	
+FunctionEnd
+
+Function Current_User_Click
+	Pop $0
+	SetShellVarContext current
+	StrCpy $INSTDIR "$LOCALAPPDATA\$(^Name)"
+	StrCpy $Install_Type "user"
+	;${NSD_SetText} $0 "user"
+	;FindWindow $0 "#32770"
+    ;GetDlgItem $1 $0 1 ;next/install button
+    ;SendMessage $1 ${WM_SETTEXT} 1 "STR:$(^NextBtn)"
+FunctionEnd
+
+;Default section----------------------
+Section 
+  SetRegView 64
+  SetOutPath $INSTDIR
+
+  !if ${BUILDTYPE} == "release"
+    File "..\build\bin\MixerQ.exe"
+  !else
+    File "..\build\bin\MixerQd.exe"
+  !endif
+  File "..\LICENSE.txt"
+
+  ;Start menu shortcut
+  createDirectory "$SMPROGRAMS\$(^Name)"
+  createShortCut "$SMPROGRAMS\$(^Name)\$(^Name).lnk" "$INSTDIR\$(^Name).exe"
+  createShortCut "$SMPROGRAMS\$(^Name)\Uninstall$(^Name).lnk" "$INSTDIR\Uninstall$(^Name).exe" 
+
+  ;Store installation folder
+  WriteRegStr SHCTX "SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\$(^Name)" "DisplayName" "$(^Name)"
+  WriteRegStr SHCTX "SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\$(^Name)" "UninstallString" '"$INSTDIR\Uninstall$(^Name).exe"'
+  WriteRegDWORD SHCTX "SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\$(^Name)" "NoModify" 1
+  WriteRegDWORD SHCTX "SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\$(^Name)" "NoRepair" 1
+  WriteRegStr   SHCTX "SOFTWARE\Microsoft\Windows\CurrentVersion\Run" "$(^Name)" "$INSTDIR\$(^Name)"
+  
+  ;Create uninstaller
+  WriteUninstaller "$INSTDIR\Uninstall$(^Name).exe"
+
+SectionEnd
+
+
+;--------------------------------
+;Descriptions
+
+  ; ;Language strings
+  ; LangString DESC_SecDummy ${LANG_ENGLISH} "A test section."
+
+  ; ;Assign language strings to sections
+  ; !insertmacro MUI_FUNCTION_DESCRIPTION_BEGIN
+  ;   !insertmacro MUI_DESCRIPTION_TEXT ${SecDummy} $(DESC_SecDummy)
+  ; !insertmacro MUI_FUNCTION_DESCRIPTION_END
+
+;--------------------------------
+;Uninstaller Section
+
+Section "Uninstall"
+  SetRegView 64  
+  
+  SetShellVarContext current
+  DeleteRegValue HKCU "SOFTWARE\Microsoft\Windows\CurrentVersion\Run" "$(^Name)" 
+  DeleteRegKey HKCU "SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\$(^Name)"
+  Delete "$SMPROGRAMS\$(^Name)\$(^Name).lnk"
+  Delete "$SMPROGRAMS\$(^Name)\Uninstall$(^Name).lnk"
+  RMDir "$SMPROGRAMS\$(^Name)"
+
+  ${If} $Is_Admin == "true"
+		SetShellVarContext all
+		DeleteRegValue HKLM "SOFTWARE\Microsoft\Windows\CurrentVersion\Run" "$(^Name)" 
+	    DeleteRegKey HKLM "SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\$(^Name)"
+		Delete "$SMPROGRAMS\$(^Name)\$(^Name).lnk"
+		Delete "$SMPROGRAMS\$(^Name)\Uninstall$(^Name).lnk"
+		RMDir "$SMPROGRAMS\$(^Name)"
+  ${EndIf}
+  
+  Delete "$INSTDIR\$(^Name).exe"
+  Delete "$INSTDIR\LICENSE.txt"
+  Delete "$INSTDIR\Uninstall$(^Name).exe"
+  ;!define PRODUCT_UNINST_ROOT_KEY "HKLM"
+  RMDir "$INSTDIR"
+  
+SectionEnd
--- a/install/version.nsi
+++ b/install/version.nsi
@ -0,0 +1,26 @@
+!if ${BUILDTYPE} == "release"
+    !define File "..\build\bin\MixerQ.exe"
+!else
+    !define File "..\build\bin\MixerQd.exe"
+!endif
+
+OutFile "GetVersion.exe"
+SilentInstall silent
+RequestExecutionLevel user ; don't write $EXEDIR\Version.txt with admin permissions and prevent invoking UAC
+
+Section
+
+ ## Get file version
+ GetDllVersion "${File}" $R0 $R1
+  IntOp $R2 $R0 / 0x00010000
+  IntOp $R3 $R0 & 0x0000FFFF
+  IntOp $R4 $R1 / 0x00010000
+  IntOp $R5 $R1 & 0x0000FFFF
+  StrCpy $R1 "$R2.$R3.$R4.$R5"
+
+ ## Write it to a !define for use in main script
+ FileOpen $R0 "$EXEDIR\Version.txt" w
+  FileWrite $R0 '!define version "$R1"'
+ FileClose $R0
+
+SectionEnd
--- a/qtest.pro
+++ b/qtest.pro
@ -1,18 +1,28 @@
-QMAKE_CXXFLAGS += --target=x86_64-w64-mingw32 -g -gcodeview 
-QMAKE_LFLAGS += --target=x86_64-w64-mingw32 -g -Wl,-pdb= -v 
-LIBS += -LC:/capybara/libclang/x86_64-w64-mingw32/lib -lWinmm -lodbc32 -lodbccp32 -luuid -loleaut32 -lole32 -lshell32 -ladvapi32 -lcomdlg32 -lwinspool -lgdi32 -luser32 -lkernel32 -lpropsys 
-#"kernel32.lib" "user32.lib" "gdi32.lib" "winspool.lib" "comdlg32.lib" "advapi32.lib" "shell32.lib" "ole32.lib" "oleaut32.lib" "uuid.lib" "odbc32.lib" "odbccp32.lib"  -luuid -loleaut32 -lole32 -lshell32 -ladvapi32 -lcomdlg32 -lwinspool -lgdi32 -luser32 -lkernel32
-DEFINES += DEBUG QT_LOGGING_TO_CONSOLE=1 WIN32_LEAN_AND_MEAN
-CONFIG += debug 
+TEMPLATE = app
+QMAKE_CXXFLAGS += --target=x86_64-w64-mingw32 -Werror=return-type 
+QMAKE_LFLAGS += --target=x86_64-w64-mingw32 -v 
+CONFIG(release, debug|release) {
+ TARGET = MixerQ
+ DESTDIR = bin
+ VERSION = 0.9.0.0
+ #QMAKE_CXXFLAGS += -O2 < Default. Modifying requires removing.
+} else {
+ TARGET = MixerQd
+ DESTDIR = bin
+ VERSION = 0.9.0.1
+ QMAKE_CXXFLAGS += -g -gcodeview -O0
+ QMAKE_LFLAGS += -g -Wl,-pdb=
+}

-QT += widgets network
+LIBS += -lWinmm -lodbc32 -lodbccp32 -luuid -loleaut32 -lole32 -lshell32 -ladvapi32 -lcomdlg32 -lwinspool -lgdi32 -luser32 -lkernel32 -lpropsys -static -stdlib=libc++ -lunwind
+DEFINES += QT_LOGGING_TO_CONSOLE=1 WIN32_LEAN_AND_MEAN _WIN32_WINNT=0x0602
+DEFINES_DEBUG += DEBUG
+
+QT += widgets network svg
 INCLUDEPATH += "$$PWD\src" "$$PWD\src\qt" "$$PWD\src\back" "$$PWD\src\back\reimpl" "$$PWD\src\cont"
-DESTPATH += "$$PWD\src" "$$PWD\src\qt" "$$PWD\src\back" "$$PWD\src\back\reimpl" "$$PWD\src\cont"
-VPATH += "$$PWD\src" "$$PWD\src\qt" "$$PWD\src\back" "$$PWD\src\back\reimpl" "$$PWD\src\cont"
+VPATH       += "$$PWD\src" "$$PWD\src\qt" "$$PWD\src\back" "$$PWD\src\back\reimpl" "$$PWD\src\cont"

-SOURCES += qtestmain.cpp qtclasses.cpp backlasses.cpp backsessionclasses.cpp contclasses.cpp contsessionclasses.cpp
-HEADERS += qtclasses.h backlasses.h backsessionclasses.h contclasses.h contsessionclasses.h global.h debug.h backfuncs.h ipolicyconfig.h msinclude.h
-RESOURCES = assets.qrc
+SOURCES += qtestmain.cpp qtclasses.cpp backlasses.cpp backsessionclasses.cpp contclasses.cpp contsessionclasses.cpp settings.cpp
+HEADERS += qtclasses.h backlasses.h backsessionclasses.h contclasses.h contsessionclasses.h global.h debug.h backfuncs.h ipolicyconfig.h msinclude.h meterslider.h qtvisuals.h settings.h
+RESOURCES = assets.qrc 
 RC_ICONS += assets/logo.ico
-
-#DESTDIR += "build"
--- a/src/back/backlasses.cpp
+++ b/src/back/backlasses.cpp
@ -1,5 +1,7 @@
-#include <backlasses.h>
-#include <backfuncs.h>
+#include "backlasses.h"
+#include "backfuncs.h"
+
+using namespace Environment;

 EndpointNewSessionCallback::EndpointNewSessionCallback(EndpointHandler* eph){
 	this->eph = eph;
@ -39,23 +41,27 @@ HRESULT EndpointNewSessionCallback::QueryInterface(REFIID riid, VOID **ppvInterf
 HRESULT EndpointNewSessionCallback::OnSessionCreated(IAudioSessionControl *NewSession) {
 	if (eph->getFlow() == Flows::FLOW_CAPTURE) return S_OK;
 	
-	HRESULT result = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE);
 	IAudioSessionControl2* sessionControl;
 	//ISimmpleAudioVolume* sessionVolume;
 	if (FAILED(NewSession->QueryInterface(__uuidof(IAudioSessionControl2), (void**)&sessionControl))) { log_wdebugcpp(L"no nueva sesion......"); };
 	if (sessionControl) {
-		sessionControl->AddRef();
-	//sessionControl->QueryInterface(__uuidof(ISimpleAudioVolume), (void**)&sessionVolume);
 		Session* newSession = new Session(this->eph->getEndpoint(), sessionControl);
-		eph->addSessionSendFront(newSession);
+		
+	    SessionThreadParams tp = { .eph = this->eph, .session = newSession, .isDelete = false };
+		wait = true;
+		std::thread newSessionThread(&EndpointNewSessionCallback::createSessionThread, this, tp);
+		newSessionThread.detach();
+		while(wait);
 	}
 	
-	if (result == S_OK)
-		CoUninitialize();
-	
 	return S_OK;
 }

+void EndpointNewSessionCallback::createSessionThread(SessionThreadParams params) {
+	params.eph->addSessionSendFront(params.session);
+	this->wait = false;
+}
+
 EndpointVolumeCallback::EndpointVolumeCallback(Endpoint* ep){
 	this->ep = ep;
 }
@ -94,46 +100,69 @@ HRESULT EndpointVolumeCallback::QueryInterface(REFIID riid, VOID **ppvInterface)
 HRESULT EndpointVolumeCallback::OnNotify(PAUDIO_VOLUME_NOTIFICATION_DATA pNotify) {
 	if (pNotify == NULL) return E_INVALIDARG;

-	//delete osh->getPlaybackEndpointHandlers().at(this->ep->getIndex())->getCallbackInfo()->caller;
-	//osh->getPlaybackEndpointHandlers().at(this->ep->getIndex())->getCallbackInfo()->caller.freeData4();
-	//Could've made a function or = override to hide this within Nguid, but back in cont = bad.
-	osh->getPlaybackEndpointHandlers().at(this->ep->getIndex())->getCallbackInfo()->caller.data1 \
-		= pNotify->guidEventContext.Data1;
-	osh->getPlaybackEndpointHandlers().at(this->ep->getIndex())->getCallbackInfo()->caller.data2 \
-		= pNotify->guidEventContext.Data2;
-	osh->getPlaybackEndpointHandlers().at(this->ep->getIndex())->getCallbackInfo()->caller.data3 \
-		= pNotify->guidEventContext.Data3;
-	for(int i = 0; i < 8 /* Data4 size */; i++){
-		osh->getPlaybackEndpointHandlers().at(this->ep->getIndex())->getCallbackInfo()->caller.data4[i] = pNotify->guidEventContext.Data4[i];
+	AUDIO_VOLUME_NOTIFICATION_DATA paramCopy;
+	memcpy(&paramCopy, pNotify, sizeof(AUDIO_VOLUME_NOTIFICATION_DATA));
+	float* channelVolumes = (float*)malloc(pNotify->nChannels * sizeof(float));
+	for (int i = 0; i < pNotify->nChannels; i++) {
+		channelVolumes[i] = pNotify->afChannelVolumes[i];
 	}
-	
-	//memcpy(&osh->getPlaybackEndpointHandlers().at(this->ep->getIndex())->getCallbackInfo()->caller, &pNotify->guidEventContext,sizeof(NGuid) );
-   Flows flow = this->ep->getFlow();
-   EndpointHandler* eph = nullptr;
-   if (flow & Flows::FLOW_PLAYBACK) {
-	   eph = osh->getPlaybackEndpointHandlers().at(this->ep->getIndex());
-   } else {
-	   eph = osh->getCaptureEndpointHandlers().at(this->ep->getIndex());
-   }
-
-   eph->getCallbackInfo()->muted = pNotify->bMuted; 
-   eph->getCallbackInfo()->mainVolume = pNotify->fMasterVolume;
-   eph->getCallbackInfo()->channels = pNotify->nChannels;
-
-	  
-   UINT j = 0;
-   //todo: do while here caused stack corruption; sus
-   while(j < pNotify->nChannels) {
-	   if (flow & Flows::FLOW_PLAYBACK)
-		   eph->getCallbackInfo()->channelVolumes[j] = pNotify->afChannelVolumes[j];
-	   else
-		   eph->getCallbackInfo()->channelVolumes[j] = pNotify->afChannelVolumes[j];
-	   j++;
-	}  
+	wait = true;
+	std::thread updateVolumeThread(&EndpointVolumeCallback::updateVolumeInfo, this, paramCopy, channelVolumes);
+	updateVolumeThread.detach();
+	while(wait);
    return S_OK;
 }

+void EndpointVolumeCallback::updateVolumeInfo(AUDIO_VOLUME_NOTIFICATION_DATA newVolume, float* channelVolumes) {
+	//delete osh->getPlaybackEndpointHandlers().at(this->ep->getIndex())->getCallbackInfo()->caller;
+	//osh->getPlaybackEndpointHandlers().at(this->ep->getIndex())->getCallbackInfo()->caller.freeData4();
+	//Could've made a function or = override to hide this within Nguid, but back in cont = bad.
+	osh->handlersPlaybackMutex.lock();
+	osh->handlersCaptureMutex.lock();
+	osh->lockEndpoints();
+	osh->getPlaybackEndpointHandlers().at(this->ep->getIndex())->getCallbackInfo()->caller.data1 \
+		= newVolume.guidEventContext.Data1;
+	osh->getPlaybackEndpointHandlers().at(this->ep->getIndex())->getCallbackInfo()->caller.data2 \
+		= newVolume.guidEventContext.Data2;
+	osh->getPlaybackEndpointHandlers().at(this->ep->getIndex())->getCallbackInfo()->caller.data3 \
+		= newVolume.guidEventContext.Data3;
+	for(int i = 0; i < 8 /* Data4 size */; i++){
+		osh->getPlaybackEndpointHandlers().at(this->ep->getIndex())->getCallbackInfo()->caller.data4[i] = newVolume.guidEventContext.Data4[i];
+	}
+	
+	//memcpy(&osh->getPlaybackEndpointHandlers().at(this->ep->getIndex())->getCallbackInfo()->caller, &newVolume.guidEventContext,sizeof(NGuid) );
+	Flows flow = this->ep->getFlow();
+	EndpointHandler* eph = nullptr;
+	if (flow & Flows::FLOW_PLAYBACK) {
+		eph = osh->getPlaybackEndpointHandlers().at(this->ep->getIndex());
+	} else {
+		eph = osh->getCaptureEndpointHandlers().at(this->ep->getIndex());
+	}

+	eph->getCallbackInfo()->muted = newVolume.bMuted;
+	eph->getCallbackInfo()->mainVolume = newVolume.fMasterVolume;
+	eph->getCallbackInfo()->channels = newVolume.nChannels;
+
+	  
+	UINT j = 0;
+	//todo: do while here caused stack corruption; sus
+	while(j < newVolume.nChannels) {
+		if (flow & Flows::FLOW_PLAYBACK)
+			eph->getCallbackInfo()->channelVolumes[j] = channelVolumes[j];
+		else
+			eph->getCallbackInfo()->channelVolumes[j] = channelVolumes[j];
+		j++;
+	}
+	free(channelVolumes);
+	osh->unlockEndpoints();
+	osh->handlersPlaybackMutex.unlock();
+	osh->handlersCaptureMutex.unlock();
+	wait = false;
+}
+
+void EndpointVolumeCallback::reportFinished() {
+	this->wait = false;
+}

 EndpointSituationCallback::EndpointSituationCallback(Overseer* os){
 	this->os = os;
@ -173,6 +202,7 @@ HRESULT EndpointSituationCallback::QueryInterface(REFIID riid, VOID **ppvInterfa

 HRESULT EndpointSituationCallback::OnDefaultDeviceChanged(EDataFlow flow, ERole role,LPCWSTR pwstrDeviceId) {
 	if (flow == EDataFlow::eCapture) return E_INVALIDARG;
+	if (!pwstrDeviceId) return E_INVALIDARG;
 	
 	Roles nRole;
 	switch (role) {
@ -188,8 +218,7 @@ HRESULT EndpointSituationCallback::OnDefaultDeviceChanged(EDataFlow flow, ERole
 	}
 	std::wstring wstringEndpointId = pwstrDeviceId;
 	log_wdebugcpp(L"we got za defol 4 " + wstringEndpointId);
-	osh->changeFrontDefaultsCallback(nRole, wstringEndpointId);
-
+	osh->roleBucketEntryCallback(nRole, wstringEndpointId);
 	return S_OK;
 }

@ -205,39 +234,54 @@ HRESULT EndpointSituationCallback::OnDeviceRemoved(LPCWSTR pwstrDeviceId) {

 HRESULT EndpointSituationCallback::OnDeviceStateChanged(LPCWSTR pwstrDeviceId, DWORD dwNewState) {
 	std::wstring endpointId = std::wstring(pwstrDeviceId);
-        switch (dwNewState){
+	log_wdebugcpp(L"Endpoint state change for " + endpointId);
+	EndpointState newState;
+        switch (dwNewState) {
        case DEVICE_STATE_ACTIVE:
-			osh->reviseEndpointShowing(endpointId, EndpointState::ENDPOINT_ACTIVE);
+			newState = EndpointState::ENDPOINT_ACTIVE;
 			break;
        case DEVICE_STATE_DISABLED:
-			osh->reviseEndpointShowing(endpointId, EndpointState::ENDPOINT_DISABLED);
+			newState = EndpointState::ENDPOINT_DISABLED;
 			break;
        case DEVICE_STATE_NOTPRESENT:
-			osh->reviseEndpointShowing(endpointId, EndpointState::ENDPOINT_NOTPRESENT);
+			newState = EndpointState::ENDPOINT_NOTPRESENT;
 			break;
        case DEVICE_STATE_UNPLUGGED:
-			osh->reviseEndpointShowing(endpointId, EndpointState::ENDPOINT_UNPLUGGED);
+			newState = EndpointState::ENDPOINT_UNPLUGGED;
 			break;
        }
-		
+		isEpStateChanging.exchange(true);
+		std::thread newEndpointThread(&OverseerHandler::reviseEndpointShowing, osh,
+						  endpointId, newState);
+		newEndpointThread.detach();
+		while(isEpStateChanging);
        return S_OK;
 }

 HRESULT EndpointSituationCallback::OnPropertyValueChanged(LPCWSTR pwstrDeviceId, const PROPERTYKEY key) {
-	os->updateEndpointInfo(std::wstring(pwstrDeviceId));
+	isEpStateChanging.exchange(true);
+	std::thread propertyThread(&Overseer::updateEndpointInfo, os, std::wstring(pwstrDeviceId));
+	propertyThread.detach();
+	while(isEpStateChanging);
 	return S_OK;
 }

-Endpoint::Endpoint(IMMDevice* ep, uint64_t idx){
+void EndpointSituationCallback::reportFinishedStateChange() {
+	this->isEpStateChanging.exchange(false);
+	return;
+}
+
+Endpoint::Endpoint(IMMDevice* ep, IPolicyConfig7* policyConfig, uint64_t idx) {
 	this->endpoint = ep;
 	this->idx = idx;
-	
+	this->policyConfig = policyConfig;
 	/*
 	 * It can't multiflag, it's that stupid. MS momento.
 	 * 	Only shows most relevant flag according to MS, i.e. 0110 sends 0010
 	 */
-	//todo: preguntitas owindows dword no es uint32_t even tho mingw mingas
-	if(FAILED(endpoint->GetState(&this->endpointState))) {exit(-2);};
+	DWORD state;
+	if(FAILED(endpoint->GetState(&state))) {exit(-2);};
+	this->endpointState = (EndpointState)state;
 	
 	if(this->endpointState == EndpointState::ENDPOINT_ACTIVE) {
 		activateEndpointVolume();
@ -248,11 +292,9 @@ Endpoint::Endpoint(IMMDevice* ep, uint64_t idx){
 		
 	}
 	
-	reloadEndpointChannels();
-	
 	//todo: atexit into exit Gather ID 
 	LPWSTR tempString = nullptr;
-	if (FAILED(endpoint->GetId(&tempString))) {exit(-1);};
+	if (FAILED(endpoint->GetId(&tempString))) { exit(-1); };
 	endpointId = std::wstring(tempString);
 	log_wdebugcpp(endpointId);
 	CoTaskMemFree(tempString);
@ -260,16 +302,14 @@ Endpoint::Endpoint(IMMDevice* ep, uint64_t idx){
 	endpoint->OpenPropertyStore(STGM_READ, 	&properties);	
 	this->updateName();
    this->setFlow();
-	if (this->flow == Flows::FLOW_PLAYBACK) {
-		activateEndpointSessions();
-		log_debugcpp("plays back");
-	}
+
+	reloadEndpointChannels();	
 }

 void Endpoint::updateName() {
 	PROPVARIANT pv;
 	#define store_name(key, propvariant, wstr) 	do {				\
-		properties->GetValue(key , &propvariant);					\
+		properties->GetValue(key, &propvariant);					\
 		if (pv.pwszVal == nullptr) 		wstr = L"Unnamed Not Present Endpoint"; \
 		else wstr = std::wstring(pv.pwszVal);						\
        } while (0)
@ -282,27 +322,34 @@ void Endpoint::updateName() {
 }

 void Endpoint::activateEndpointSessions() {	
-    //sessionManager;
-	if (FAILED(endpoint->Activate(__uuidof(IAudioSessionManager2), CLSCTX_ALL, NULL, (void**) &sessionManager))) { log_wdebugcpp(L"sesionbros..."); return; }
-	
+	if (this->flow != Flows::FLOW_PLAYBACK) {
+		log_debugcpp("recording. No seshes for u :(");
+		return;
+	}
+
+	if (!sessionManager) {
+		if (FAILED(endpoint->Activate(__uuidof(IAudioSessionManager2),
+									  CLSCTX_ALL, NULL, (void**) &sessionManager))) {
+			log_debugcpp("Couldn't open session manager2, huh");
+			return;
+		}
+	}
+
 	IAudioSessionEnumerator* sessionEnumerator = nullptr;
-	if (FAILED(sessionManager->GetSessionEnumerator(&sessionEnumerator))) { log_wdebugcpp(L"sesEnumeratorBros..."); return; }
+	if (FAILED(sessionManager->GetSessionEnumerator(&sessionEnumerator))) { log_wdebugcpp(L"sesEnumeratorBros..."); exit(-5); return; }

 	endpointSessions.resize(1, nullptr);
 	int sessionCount;
 	sessionEnumerator->GetCount(&sessionCount);
-	for (int i = 0; i < sessionCount; i++) {
+	for (int i = 0; i < sessionCount; i++) { 
 		IAudioSessionControl* sessionControlTmp;
-		sessionEnumerator->GetSession(i, (IAudioSessionControl**)&sessionControlTmp);
-		/*todo: borrar when donezo
-		 * float test2;
-		 * IAudioMeterInformation* ttmp = (IAudioMeterInformation*)sessionControlTmp;
-		 * ttmp->GetPeakValue(&test2);
-		 */
-		//todo:: asegurar lo del dynamic_cast
+		if (FAILED(sessionEnumerator->GetSession(i, (IAudioSessionControl**)&sessionControlTmp))) {
+			exit(-6);
+		}
 		IAudioSessionControl2* sessionControl;
-		sessionControlTmp->QueryInterface(__uuidof(IAudioSessionControl2), (void**)&sessionControl);
-		sessionControl->AddRef();
+		if(FAILED(sessionControlTmp->QueryInterface(__uuidof(IAudioSessionControl2), (void**)&sessionControl))){
+			exit(-7);
+		}
 		sessionControlTmp->Release();
 		Session* session = new Session(this, sessionControl, (size_t)i);
 		if (sessionControl->IsSystemSoundsSession() == S_OK) endpointSessions[0] = session;
@ -311,34 +358,38 @@ void Endpoint::activateEndpointSessions() {
 	sessionEnumerator->Release();
 }

+/*
+ * void Endpoint::deleteSessionManager() {
+ * 	sessionManager->Release();
+ * 	sessionManager = nullptr;
+ * }
+ */
+
 void Endpoint::addSession(Session* session) {
 	session->setIndex(this->getSessionCount());
 	endpointSessions.push_back(session);
 }

 void Endpoint::activateEndpointVolume() {
-	//bool extraThread = false;
-	/*
-	 * Forgive me, for MS has sinned, and now I must too.
-	 */
-	if (this->endpointVolume == nullptr){
-		HRESULT result = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE);
-		endpoint->Activate(IID_IAudioEndpointVolume, CLSCTX_ALL, NULL, (void**)&this->endpointVolume);
+	//If this EP is created after init, COM won't be initialized on the executing thread.
+	HRESULT result = CoInitializeEx(NULL, COINIT_MULTITHREADED | COINIT_DISABLE_OLE1DDE);
+	if (this->endpointVolume == nullptr) {
+		if(FAILED(endpoint->Activate(
+									 IID_IAudioEndpointVolume,
+									 CLSCTX_ALL,
+									 NULL,
+									 (void**)&this->endpointVolume))) {
+			log_debugcpp("No volume, huh");
+		}

 		//todo: check header
 		if(FAILED(endpoint->Activate(__uuidof(IAudioMeterInformation),
-								 CLSCTX_ALL, NULL, (void**)&endpointPeakMeter))) { log_debugcpp("peakbros..."); }
-		//
-		
-		//if (endpointVolume == nullptr) { //why they returning 0 after dealing with the error jfc CO_E_NOTINITIALIZED) {
-			//CoInitializeEx(NULL, COINIT_MULTITHREADED | COINIT_DISABLE_OLE1DDE);
-			//extraThread = true;
-		    //goto initialized;
-		//}
-		//log_debugcpp(std::string("no endpointVolume (IAudioEndpointVolume)"));
-		if (result == S_OK)
-			CoUninitialize();
+								 CLSCTX_ALL, NULL, (void**)&endpointPeakMeter))) {
+			log_debugcpp("peakbros...");
+		}
 	}
+	if (result == S_OK)
+		CoUninitialize();
 }

 void Endpoint::reloadEndpointChannels() {
@ -391,7 +442,7 @@ bool Endpoint::getMute(){
 	return mute;
 }

-void Endpoint::setState(uint8_t state){
+void Endpoint::setState(EndpointState state){
 	this->endpointState = state;
 	if(state == EndpointState::ENDPOINT_ACTIVE) {
 		this->activateEndpointVolume();
@ -399,7 +450,7 @@ void Endpoint::setState(uint8_t state){
 	}
 }

-size_t Endpoint::getState(){
+EndpointState Endpoint::getState(){
 	return this->endpointState;
 }

@ -407,9 +458,13 @@ void Endpoint::setVolume(NGuid guid, int channel, float volume) {
 	//TIP: There used to be log messages here. Now, it's a ghost town.
 	GUID tempMsGuid = NGuidToGUID(guid);
 	if (channel == AudioChannel::CHANNEL_MAIN) {
-		if(FAILED(endpointVolume->SetMasterVolumeLevelScalar(volume, &tempMsGuid))) {};
+		if(FAILED(endpointVolume->SetMasterVolumeLevelScalar(volume, &tempMsGuid))) {
+			log_wdebugcpp(L"Master volume failed for endpoint: " + friendlyName);
+		};
 	} else {
-		if(FAILED(endpointVolume->SetChannelVolumeLevelScalar(channel, volume, &tempMsGuid))) {};
+		if(FAILED(endpointVolume->SetChannelVolumeLevelScalar(channel, volume, &tempMsGuid))) {
+			log_wdebugcpp(L"Channel " + std::to_wstring(channel) + L" volume failed for endpoint: " + friendlyName);
+		};
 	}
 }

@ -434,70 +489,29 @@ Roles Endpoint::getRoles(){
 }

 void Endpoint::setRoles(Roles role){
-	//todo: otro exe momento
-	STARTUPINFOEXW startupConfig;
-	PROCESS_INFORMATION processInfo;
-	SecureZeroMemory(&startupConfig, sizeof(STARTUPINFOEXW));
-	SecureZeroMemory(&startupConfig.StartupInfo, sizeof(STARTUPINFOW));
-	startupConfig.StartupInfo.cb = sizeof(STARTUPINFOEXW);
-	SecureZeroMemory(&processInfo, sizeof(PROCESS_INFORMATION));
+	if (!policyConfig) return;

-	std::wstring command = L"SoundVolumeView.exe /SetDefault " + endpointId + L" ";
-	std::wstring troublePair = L"1";	
-	switch (role) {
-	case Roles::ROLE_ALL:
-	/*
-	 * console or multimedia, one sends both, at least for now;
-	 *  either cos of ms or dis guy;
-	 *  no choice but to treat them as one for now.
-	 *  command += L"all"; and nothing else would've been nice...
-	 */
-		troublePair = command + troublePair;
-		if(CreateProcessW(
-					  NULL,
-					  (wchar_t*)troublePair.c_str(),
-					  NULL,
-					  NULL,
-					  false,
-					  CREATE_UNICODE_ENVIRONMENT,
-					  NULL,
-					  NULL,
-					  (LPSTARTUPINFOW)&startupConfig,
-					  &processInfo
-					  ) == true)  {
-			WaitForSingleObject(processInfo.hProcess, INFINITE );  
-			CloseHandle(processInfo.hProcess);
-			CloseHandle(processInfo.hThread);
-		}
-		command += L"2";
-		break;
+	bool allRoles = false;
+	ERole val;
+	switch(role) {
 	case Roles::ROLE_CONSOLE:
-		command += std::to_wstring(0);
+		val = eConsole;
 		break;
 	case Roles::ROLE_MULTIMEDIA:
-		command += std::to_wstring(1);
+		val = eMultimedia;
 		break;
 	case Roles::ROLE_COMMUNICATIONS:
-		command += std::to_wstring(2);
+		val = eCommunications;
+		break;
+	default:
+		allRoles = true;
 		break;
 	}
-	
-	if(CreateProcessW(
-		NULL,
-		(wchar_t*)command.c_str(),
-		NULL,
-		NULL,
-		false,
-		CREATE_UNICODE_ENVIRONMENT,
-		NULL,
-		NULL,
-		(LPSTARTUPINFOW)&startupConfig,
-		&processInfo
-	   ) == true)  {
-		WaitForSingleObject(processInfo.hProcess, INFINITE );  
-		CloseHandle(processInfo.hProcess);
-		CloseHandle(processInfo.hThread);
-	}
+	if (allRoles) {
+		policyConfig->SetDefaultEndpoint(endpointId.c_str(), eMultimedia);	 
+		//policyConfig->SetDefaultEndpoint(endpointId.c_str(), eConsole);
+		policyConfig->SetDefaultEndpoint(endpointId.c_str(), eCommunications);	 
+	} else policyConfig->SetDefaultEndpoint(endpointId.c_str(), val);	 
 }

 void Endpoint::assignRoles(Roles role){ 
@ -512,11 +526,10 @@ void Endpoint::removeRoles(Roles role){

 void Endpoint::setFlow() {
 	IMMEndpoint* flowGetter;
-	//this should be as simple as writing IID_IMMEndpoint, but it just won't find the macro, so I reimpl it. Sad.
 	if(FAILED(this->endpoint->QueryInterface(__uuidof(IMMEndpoint), (void**)&flowGetter)))
 		{ log_debugcpp("no flow..."); }
 	EDataFlow MSflow;
-	HRESULT vafllar = flowGetter->GetDataFlow(&MSflow);
+	flowGetter->GetDataFlow(&MSflow);
 	this->flow = (MSflow == EDataFlow::eRender ? Flows::FLOW_PLAYBACK : Flows::FLOW_CAPTURE);
 	log_debugcpp("Endpoint flow: " + std::to_string(flow));
 	flowGetter->Release();
@ -532,7 +545,9 @@ std::vector<Session*> Endpoint::getSessions() {
 }

 size_t Endpoint::getSessionCount() {
-	return endpointSessions.size();
+	size_t sessionCount;
+	sessionCount = endpointSessions.size();
+	return sessionCount;
 }

 void Endpoint::registerNewSessionNotification(EndpointNewSessionCallback* ensc){
@ -543,18 +558,28 @@ void Endpoint::unregisterNewSessionNotification(EndpointNewSessionCallback* ensc
 	sessionManager->UnregisterSessionNotification(ensc);
 }

+void Endpoint::deleteSessions() {
+	for (auto session : endpointSessions) {
+		delete session;
+	}
+	endpointSessions.resize(0);
+}
+
 Endpoint::~Endpoint(){
+	//EPs are never deleted. 
 	log_wdebugcpp(L"murio endpoint-san uwu");
 	properties->Release();
 	endpointVolume->Release();
 	endpoint->Release();
 	sessionManager->Release();
+	for (auto session : endpointSessions) {
+		delete session;
+	}
 }

 void Overseer::initCOMLibrary() {
-	OutputDebugStringW(L"EPWidget creation\n");
 	if(FAILED(CoInitializeEx(NULL, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE))) {
-		log_debugcpp("si");  };
+		log_debugcpp("Not even COM?");  };


 	//Retrieving endpoint enumerator
@ -562,7 +587,7 @@ void Overseer::initCOMLibrary() {
 	if(FAILED(CoCreateInstance( __uuidof(MMDeviceEnumerator), NULL,
 								CLSCTX_ALL, __uuidof(IMMDeviceEnumerator),
 								(void**)&deviceEnumerator)) )
-		{ log_debugcpp("si"); };
+		{ log_debugcpp("No MMDeviceEnum. Weird."); };

 	GUID tempGuid;
 	if(FAILED(CoCreateGuid(&tempGuid))) { log_debugcpp("Failed to obtain GUID: " ); };
@ -578,7 +603,7 @@ void Overseer::initCOMLibrary() {
 	//TODO: Uninitialize COM
 }

-void Overseer::reloadEndpoints(Flows flow) {
+void Overseer::createEndpoints(Flows flow) {
 	IMMDeviceCollection *deviceCollection;
 	unsigned int numEndpoints;
 	EDataFlow MSflow = (flow == Flows::FLOW_PLAYBACK ? EDataFlow::eRender : EDataFlow::eCapture);
@ -590,8 +615,8 @@ void Overseer::reloadEndpoints(Flows flow) {
 	/*
 	 * Counting them
 	 */
-		if(FAILED(deviceCollection->GetCount(&numEndpoints))) { log_debugcpp("si");};
-		if(numEndpoints == 0) { log_debugcpp("si");  };
+	if(FAILED(deviceCollection->GetCount(&numEndpoints))) { log_debugcpp("si");};
+	if(numEndpoints == 0) { log_debugcpp("si");  };
 	
 	/*
 	 * Retrieving actual endpoints and storing them on their own collection
@ -599,7 +624,7 @@ void Overseer::reloadEndpoints(Flows flow) {
 	IMMDevice *temp;
 	for (unsigned int i = 0; i < numEndpoints; i++){
 		if(deviceCollection->Item(i, &temp) != 0) { log_debugcpp("si"); };
-		Endpoint *endpoint = new Endpoint(temp, i);
+		Endpoint *endpoint = new Endpoint(temp, policyConfig, i);
 		if (flow == Flows::FLOW_PLAYBACK)
 			this->playbackDevices.push_back(endpoint);
 		else
@ -608,16 +633,6 @@ void Overseer::reloadEndpoints(Flows flow) {
 	}

 	deviceCollection->Release();
-	//IPolicyConfig7 test
-	/*
-	 * deviceEnumerator->GetDefaultAudioEndpoint(MSflow, ERole::eCommunications, &temp);
-	 * LPWSTR tempString = nullptr;
-	 * temp->GetId(&tempString);
-	 * HRESULT hre = policyConfig->SetDefaultEndpoint(
-	 * 	tempString,
-	 * 	ERole::eMultimedia
-	 * );	 
-	 */

 	/*
 	 * Discerning default endpoints per role
@ -637,6 +652,8 @@ void Overseer::reloadEndpoints(Flows flow) {
 			break;
 		}
 		deviceEnumerator->GetDefaultAudioEndpoint(MSflow, val, &temp);
+		if (!temp) continue;
+		
 		LPWSTR id = nullptr;

 		if (flow == Flows::FLOW_PLAYBACK) {
@ -666,11 +683,17 @@ void Overseer::reloadEndpoints(Flows flow) {
 }

 Endpoint* Overseer::addEndpoint(std::wstring endpointId, /* out */Flows* flow = nullptr) {
+	//This method is only called from the new endpoint callback and its subsequent thread,
+	//so another STA can be safely instantiated
+	if(FAILED(CoInitializeEx(NULL, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE))) {
+		log_debugcpp("EP Callback Thread failed. Sad!");
+		return nullptr;
+	}
 	IMMDevice* newep;
 	if(FAILED(deviceEnumerator->GetDevice((LPCWSTR)endpointId.c_str(), &newep)))
-		log_debugcpp("ay caramba con la hot metida.");
+		log_debugcpp("ay caramba con la hot metida. Sad!");

-	Endpoint *endpoint = new Endpoint(newep);
+	Endpoint *endpoint = new Endpoint(newep, policyConfig);
 	
 	Flows getFlow = endpoint->getFlow();
 	if (getFlow == Flows::FLOW_PLAYBACK) {
@ -681,25 +704,179 @@ Endpoint* Overseer::addEndpoint(std::wstring endpointId, /* out */Flows* flow =
 		this->captureDevices.push_back(endpoint);
    }
 	if (flow != nullptr) *flow = getFlow;
+	CoUninitialize();
 	return endpoint;
 }

-Overseer::Overseer() : epsc(this){
-	//Initializing COM library
+void Overseer::reportFinishedStateChange() {
+	epsc.reportFinishedStateChange();
+}
+
+Overseer::Overseer() : epsc(this) {
 	log_debugcpp("Initializing Overseer");
+
+	//Storing exe path for later use (mainly "Run on startup")
+	log_debugcpp("-Caching exe path");
+	uint32_t cPathLen = 0;
+	wchar_t* cPath = getExeAbsPath(&cPathLen);
+	exeAbsPath = cPath;
+
+	//Detecting install scope
+	wchar_t *machine = wcsstr(cPath, L"Program Files");
+	if (!machine)
+		Environment::scope = HKEY_CURRENT_USER;
+	else Environment::scope = HKEY_LOCAL_MACHINE;
+	free(cPath);
+
+	//Initializing COM library
+	log_debugcpp("-Initializing COM");
 	initCOMLibrary();
 	
-	//Obtaining playback endpoint collection on this point in time
-	reloadEndpoints(Flows::FLOW_PLAYBACK);
+	//Obtaining playback endpoint collection
+	createEndpoints(Flows::FLOW_PLAYBACK);
 	//reloadEndpoints(Flows::FLOW_CAPTURE);
+}

-	//Registering for endpoint information callback
-	//this->epsc.fill(deviceEnumerator, playbackDevices, captureDevices);
-	//this->epsc.fill(deviceEnumerator);
+NGuid Overseer::getGuid() {
+	return guid;
+}
+
+void Overseer::registerEndpointSituationCallback() {
 	if(FAILED(deviceEnumerator->RegisterEndpointNotificationCallback(((IMMNotificationClient*)&epsc)))) { log_debugcpp("when no enchufas......"); }
 }

-void Overseer::openControlPanel() {
+std::vector<Endpoint*> Overseer::getPlaybackEndpoints() {
+	return playbackDevices;
+}
+
+std::vector<Endpoint*> Overseer::getCaptureEndpoints() {
+	return captureDevices;
+}
+
+void Overseer::updateEndpointInfo(std::wstring endpointId) {
+	//todo: reintroduce capture devices
+	playbackMutex.lock();
+	log_wdebugcpp(L"new name Endpoint id: " + endpointId);
+	for(auto ep : playbackDevices) {
+		if (ep->getId() == endpointId && ep->getState() == EndpointState::ENDPOINT_ACTIVE) {
+			ep->updateName();
+			osh->updateFrontEndpointName(ep);
+			break;
+		}
+	}
+	playbackMutex.unlock();
+	epsc.reportFinishedStateChange();
+}
+
+Overseer::~Overseer(){
+	//Overseer is never deleted. This is to annotate what would need to be taken care of.
+	log_debugcpp("jej");
+	deviceEnumerator->Release();
+	for(unsigned long long i = 0; i < playbackDevices.size(); i++){
+		delete(playbackDevices.at(i));
+	}
+}
+
+wchar_t* Environment::getExeAbsPath(uint32_t *exeAbsPathLength) {
+	wchar_t *exeAbsPath = (wchar_t*)calloc(UNICODE_STRING_MAX_CHARS, sizeof(wchar_t));
+	*exeAbsPathLength = GetModuleFileNameW(
+									   NULL,
+									   exeAbsPath,
+									   UNICODE_STRING_MAX_CHARS
+									   );
+	return exeAbsPath;
+}
+
+std::string Environment::createSettingsPath(SettingsTargetDirectory target) {
+	wchar_t* settingsPath = nullptr;
+	wchar_t settingsFile[] = L"\\settings.ini";
+	uint32_t settingsFileLen  = (sizeof(settingsFile) / sizeof(wchar_t)) - 1;
+	wchar_t maxPathBypass[] = L"\\\\?\\";
+	uint32_t exePathLength = 0;
+	wchar_t folderPath[] = L"\\" LAPP_NAME;
+	uint32_t maxPathBypassLen = (sizeof(maxPathBypass)/ sizeof(wchar_t)) - 1;
+	uint32_t folderPathLen    = (sizeof(folderPath)   / sizeof(wchar_t)) - 1;
+	wchar_t* roamingPath = nullptr;
+
+	log_wdebugcpp(L"Bypass size: " + std::to_wstring((sizeof(maxPathBypass)/sizeof(maxPathBypass[0]))));
+
+	switch(target) {
+	case HOME_DIR:
+		{
+			if(SHGetKnownFolderPath(
+									FOLDERID_RoamingAppData,
+									0,
+									NULL,
+									&roamingPath)
+			   == S_OK) {
+				//Retrieve path len
+				uint32_t pathLen = 0;
+				wchar_t currentChar = roamingPath[pathLen];
+				while(currentChar != '\0') {
+					pathLen++;
+					currentChar = roamingPath[pathLen];
+				}
+
+				settingsPath = (wchar_t*)calloc(pathLen +
+												maxPathBypassLen +
+												folderPathLen +
+												settingsFileLen,
+												sizeof(wchar_t));
+				memcpy(settingsPath, maxPathBypass, sizeof(wchar_t) * maxPathBypassLen);
+				memcpy(settingsPath + (maxPathBypassLen), roamingPath, sizeof(wchar_t) * pathLen);
+				CoTaskMemFree(roamingPath);
+				memcpy(settingsPath + (maxPathBypassLen + pathLen),
+					   folderPath, sizeof(wchar_t) * folderPathLen);
+				log_wdebugcpp(L"Settings folder path: " + std::wstring(settingsPath));
+
+				if(CreateDirectoryW(settingsPath, NULL) || GetLastError() == ERROR_ALREADY_EXISTS) {
+					memcpy(settingsPath + (maxPathBypassLen + pathLen + folderPathLen),
+						   settingsFile, sizeof(wchar_t) * settingsFileLen);
+					std::string utf8path = utf16ToUtf8(settingsPath);
+					free(settingsPath);
+					return utf8path;
+				}
+			}
+		}
+		return nullptr;
+		break;
+	case APP_PATH:
+		{
+			//Executable dir
+			settingsPath = getExeAbsPath(&exePathLength);
+
+			//reverse wcsstr
+			while(exePathLength >= 0) {
+				if(settingsPath[exePathLength] == '\\') {
+					memset(settingsPath + exePathLength,
+						   0,
+						   (UNICODE_STRING_MAX_CHARS - exePathLength) * sizeof(wchar_t));
+					break;
+				} else exePathLength--;
+			}
+			log_wdebugcpp(L"Exe folder: " + std::wstring(settingsPath));
+			if((UNICODE_STRING_MAX_CHARS - exePathLength) > (settingsFileLen + 1)) {
+				memcpy(settingsPath + exePathLength, settingsFile, sizeof(wchar_t) * settingsFileLen);
+				std::string utf8path = utf16ToUtf8(settingsPath);
+				free(settingsPath);
+				return utf8path;
+			}
+		}
+		return nullptr;
+		break;
+	default:
+		return nullptr;
+		break;
+	}
+	return nullptr;
+}
+
+void Environment::populateSystemValues() {
+	updateColors();
+	Environment::startup = checkStartup(scope);
+}
+
+void Environment::openControlPanel() {
 	STARTUPINFOEXW startupConfig;
 	PROCESS_INFORMATION processInfo;
 	SecureZeroMemory(&startupConfig, sizeof(STARTUPINFOEXW));
@ -725,36 +902,146 @@ void Overseer::openControlPanel() {
 	}
 }

-NGuid Overseer::getGuid() {	
-	return guid;
-}
- 
-std::vector<Endpoint*> Overseer::getPlaybackEndpoints() {
-	return playbackDevices;
-}
-
-std::vector<Endpoint*> Overseer::getCaptureEndpoints() {
-	return captureDevices;
-}
-
-void Overseer::updateEndpointInfo(std::wstring endpointId) {
-	log_wdebugcpp(L"new name Endpoint id: " + endpointId);
-	//todo: reintroduce capture devices
-	for(auto ep : playbackDevices) {
-		if (ep->getId() == endpointId) {
-			ep->updateName();
-			osh->updateFrontEndpointName(ep);
-			break;
-		}	
+ProcessedNativeEvent Environment::processTopLevelWindowMessage(void* msg) {
+#ifdef WIN32
+	MSG *message = static_cast<MSG *>(msg);
+	switch(message->message) {
+	case WM_SETTINGCHANGE:
+		//TODO: This looks like a future pain point. Ex handler would come in clutch
+		if(message->lParam && !wcscmp(((wchar_t*)message->lParam), L"ImmersiveColorSet"))
+			return updateColors();
+		break;
+	default:
+		return ProcessedNativeEvent::NONE;
+		break;
 	}
+	return ProcessedNativeEvent::NONE;
+	//if (message->message != WM_SETTINGCHANGE) {return false;}
+#endif
 }

-Overseer::~Overseer(){
-	log_debugcpp("cum");
-	deviceEnumerator->Release();
-	for(unsigned long long i = 0; i < playbackDevices.size(); i++){
-		delete(playbackDevices.at(i));
+ProcessedNativeEvent Environment::updateColors() {
+	// DwmGetColorizationColor( WM_DWMCOLORIZATIONCOLORCHANGED
+	DWORD value = 0;
+	DWORD size = sizeof(DWORD);
+	
+	LSTATUS result;
+	
+	//Theme bg color
+	result = RegGetValueW(HKEY_CURRENT_USER, L"Software\\Microsoft\\Windows\\CurrentVersion\\Themes\\Personalize", L"AppsUseLightTheme", RRF_RT_REG_DWORD, nullptr, &value, &size);
+	lightMode = (bool)value;
+
+	//Accent color
+	result = RegGetValueW(HKEY_CURRENT_USER, L"Software\\Microsoft\\Windows\\DWM", L"ColorizationColor", RRF_RT_REG_DWORD, nullptr, &value, &size);
+	if (result == ERROR_SUCCESS) {
+		accentColor = value;
+	} else accentColor = 0xffffffff;
+	
+	return ProcessedNativeEvent::COLORS;
+}
+
+bool Environment::checkStartup(HKEY rootKeyFlags) {
+	//LSTATUS result;
+	DWORD typeReturned;
+
+	//Checking if app entry exists
+	if(RegGetValueW(rootKeyFlags, L"Software\\Microsoft\\Windows\\CurrentVersion\\Run", LAPP_NAME, RRF_RT_REG_SZ, &typeReturned, nullptr, nullptr) != ERROR_SUCCESS && typeReturned != REG_SZ)
+		return false;
+	else return true;
+}
+
+void Environment::updateStartupConfig(bool onStartup) {
+	wchar_t regSubKey[] = L"Software\\Microsoft\\Windows\\CurrentVersion\\Run\\";
+
+	if(!onStartup) {
+		HKEY runKey;
+		if (RegOpenKeyExW(
+							  scope,
+							  regSubKey,
+							  0,
+							  KEY_SET_VALUE,
+							  &runKey
+							  )
+			== ERROR_SUCCESS) {
+			RegDeleteValueW(runKey, LAPP_NAME);
+			RegCloseKey(runKey);
+		}
+	} else {
+		LSTATUS result;
+		uint32_t cPathLen = 0;
+		wchar_t* cPath = getExeAbsPath(&cPathLen);
+		wchar_t* regPath = (wchar_t*)calloc(UNICODE_STRING_MAX_CHARS + 2, sizeof(wchar_t));
+		//char* v = 0xFF'00'00'00'00'00'00'21;
+		regPath[0] = L'"';
+		memcpy(regPath + 1, cPath, sizeof(wchar_t) * cPathLen);
+		memcpy(regPath + cPathLen + 1, L"\"", sizeof(wchar_t) * 2);
+
+		result = RegSetKeyValueW(
+						scope,
+						regSubKey,
+						LAPP_NAME,
+						REG_SZ,
+						(void*)regPath,
+						(cPathLen + 3) * sizeof(wchar_t));
+		/*
+		 * if (result != ERROR_SUCCESS) {
+		 * 	wchar_t* error;
+		 * 	FormatMessageW(
+		 * 				  FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
+		 * 				  nullptr,
+		 * 				  (DWORD)result,
+		 * 				  LANG_USER_DEFAULT,
+		 * 				  error,
+		 * 				  1,
+		 * 				  nullptr);
+		 * 	LocalFree(error);
+		 * }
+		 */
+		free(cPath);
 	}
+	return;
+}
+
+void Environment::setStartupConfig(bool onStartup) {
+	//TODO: Use the cache!!!! lol
+	uint32_t cPathLen = 0;
+	wchar_t* cPath = getExeAbsPath(&cPathLen);
+	wchar_t startupParam[] = L"--change-startup";
+	uint32_t startupParamLen  = (sizeof(startupParam) / sizeof(wchar_t)) - 1;
+	wchar_t* completeParam = (wchar_t*)calloc(startupParamLen + 3, sizeof(wchar_t));
+	memcpy(completeParam, startupParam, sizeof(wchar_t) * startupParamLen);
+	if (onStartup)
+		memcpy(completeParam + startupParamLen, L" 1", sizeof(wchar_t) * 3);
+	else
+		memcpy(completeParam + startupParamLen, L" 0", sizeof(wchar_t) * 3);
+
+	if(scope == HKEY_LOCAL_MACHINE) {
+		ShellExecuteW(
+					 NULL,
+					 L"runas",
+					 cPath,
+					 completeParam,
+					 NULL,                        // default dir 
+					 SW_SHOWNORMAL
+					  );
+	} else {
+		Environment::updateStartupConfig(onStartup);
+	}
+	free(cPath);
+	free(completeParam);
+	return;
+}
+
+bool Environment::isLightMode() {
+	return lightMode;
+}
+
+bool Environment::isToRunAtStartup() {
+	return startup;
+}
+
+uint32_t Environment::getAccentColor() {
+	return accentColor;
 }

 //int Overseer::getCaptureEndpoints(std::vector<Endpoint*> *captureEndpoints);
--- a/src/back/backlasses.h
+++ b/src/back/backlasses.h
@ -4,14 +4,50 @@
 #include "backsessionclasses.h"
 #include "global.h"
 #include "contclasses.h"
+//#include "environment.h"

 class EndpointVolumeCallback;
 class Session;

+// Convert a wide UTF16LE string to an UTF8 string
+static inline std::string utf16ToUtf8(const wchar_t* wstr) {
+    if(!wstr || wstr[0] == '\0') return std::string();
+    int size_needed = WideCharToMultiByte(CP_UTF8,
+										  0,
+										  wstr,
+										  -1,
+										  NULL,
+										  0,
+										  NULL,
+										  NULL);
+    std::string str(size_needed, 0);
+    WideCharToMultiByte(CP_UTF8,
+						0,
+						wstr,
+						-1,
+						&str[0],
+						size_needed,
+						NULL,
+						NULL);
+    return str;
+}
+
+// Convert an UTF8 string to a wide UTF16LE String
+/*
+ * std::wstring utf8_decode(const std::string &str)
+ * {
+ *     if( str.empty() ) return std::wstring();
+ *     int size_needed = MultiByteToWideChar(CP_UTF8, 0, &str[0], (int)str.size(), NULL, 0);
+ *     std::wstring wstrTo( size_needed, 0 );
+ *     MultiByteToWideChar                  (CP_UTF8, 0, &str[0], (int)str.size(), &wstrTo[0], size_needed);
+ *     return wstrTo;
+ * }
+ */
+
 class Endpoint {
 	
 public:
-	Endpoint(IMMDevice* endpoint, uint64_t idx = 0);
+	Endpoint(IMMDevice* endpoint, IPolicyConfig7* policyConfig, uint64_t idx = 0);
 	//todo: how to forward declare delegate constructors?
 	//Endpoint(IMMDevice* endpoint) : Endpoint(endpoint, 0) {};
 	void reloadEndpointChannels();
@ -22,8 +58,8 @@ class Endpoint {
 	float getVolume(int channel);
 	void setMute(NGuid guid, bool muted);
 	bool getMute();
-	void setState(uint8_t state);
-	size_t getState();
+	void setState(EndpointState state);
+	EndpointState getState();
 	Roles getRoles();
 	void setRoles(Roles role);
 	void assignRoles(Roles role);
@ -44,32 +80,34 @@ class Endpoint {
 	void addSession(Session* session);
 	void registerNewSessionNotification(EndpointNewSessionCallback* ensc);
 	void unregisterNewSessionNotification(EndpointNewSessionCallback* ensc);
-	
+	void deleteSessions();
+	void activateEndpointSessions();
+	//void deleteSessionManager();
+	std::mutex endpointSessionsMutex;
 	~Endpoint();
 	
 private:
 	void inline activateEndpointVolume();
-	void inline activateEndpointSessions();

 	std::vector<Session*> endpointSessions;
 	uint32_t channelCount = 0;
 	IMMDevice *endpoint;
-	IAudioClient *audioClient;
-	int64_t defTime, minTime;
-	IAudioSessionManager2 *sessionManager;
-	Flows flow;
-	IAudioEndpointVolume *endpointVolume = nullptr;	
+	IAudioEndpointVolume *endpointVolume = nullptr;
 	IPropertyStore *properties;
+	IAudioMeterInformation *endpointPeakMeter = nullptr;
+	//IAudioClient *audioClient;
+	int64_t defTime, minTime;
+	IAudioSessionManager2 *sessionManager = nullptr;
+	Flows flow;
 	std::wstring friendlyName;
 	std::wstring descriptionName;
 	std::wstring deviceName;
 	std::wstring endpointId;
-	unsigned long endpointState;
+	EndpointState endpointState;
 	Roles endpointRoles = (Roles)0;
 	uint64_t idx;
 	//Not implemented in llvm-mingw. Sad! todo: mingw patch
-	IAudioMeterInformation *endpointPeakMeter = nullptr;
-	
+	IPolicyConfig7* policyConfig;
 };

 class EndpointVolumeCallback : public IAudioEndpointVolumeCallback {
@ -81,11 +119,14 @@ class EndpointVolumeCallback : public IAudioEndpointVolumeCallback {
 	ULONG Release();
    HRESULT QueryInterface(REFIID riid, VOID **ppvInterface);
 	HRESULT OnNotify(PAUDIO_VOLUME_NOTIFICATION_DATA update);
+	void updateVolumeInfo(AUDIO_VOLUME_NOTIFICATION_DATA newVolume, float* channelVolumes);
+	void reportFinished();
 	//~EndpointVolumeCallback();

 private:
 	ULONG ref = 1;
 	Endpoint* ep;
+	std::atomic<bool> wait = false;
 };

 class EndpointSituationCallback : public IMMNotificationClient {
@ -99,24 +140,31 @@ class EndpointSituationCallback : public IMMNotificationClient {
    HRESULT OnDeviceRemoved(LPCWSTR pwstrDeviceId);
    HRESULT OnDeviceStateChanged(LPCWSTR pwstrDeviceId, DWORD dwNewState);
 	HRESULT OnPropertyValueChanged(LPCWSTR pwstrDeviceId, const PROPERTYKEY key);
-
+	void reportFinishedStateChange();
 private:
 	ULONG ref = 1;
 	Overseer* os;
+	std::atomic<bool> isEpStateChanging = false;
 };

 class Overseer {

 public:
 	Overseer();
-	void openControlPanel();
+	void registerEndpointSituationCallback();
+	NGuid getGuid();
+	
 	std::vector<Endpoint*> getPlaybackEndpoints();
 	std::vector<Endpoint*> getCaptureEndpoints();
 	void updateEndpointInfo(std::wstring endpointId);
 	
-	void reloadEndpoints(Flows flow);
+	void createEndpoints(Flows flow);
 	Endpoint* addEndpoint(std::wstring endpointId, /* out */ Flows* flow);
-	NGuid getGuid();
+
+	void reportFinishedStateChange();
+	
+	std::mutex playbackMutex;
+	std::mutex captureMutex;
 	//void setEndpointStatusCallback();
 	//void setEndpointStatusCallback();
 	
@ -128,29 +176,65 @@ class Overseer {
 	~Overseer();
 	
 private:
+	void initCOMLibrary();
+	
 	NGuid guid;
 	
 	IMMDeviceEnumerator *deviceEnumerator;
 	EndpointSituationCallback epsc;
-	//IPolicyConfig *policyConfig;
+	
 	std::vector<Endpoint*> playbackDevices;
 	std::vector<Endpoint*> captureDevices;
-	void initCOMLibrary();
 	IPolicyConfig7* policyConfig;
+	friend class Endpoint;
 	//IMMDeviceCollection *deviceCollection;
 	//int numCaptureEndpoints;
 	//std::vector<Endpoint*> *captureDevices;	
 };

 class EndpointNewSessionCallback : public IAudioSessionNotification {
+ private:
+	struct SessionThreadParams;
+	
 public:
 	EndpointNewSessionCallback(EndpointHandler *eph);
 	ULONG AddRef();
 	ULONG Release();
    HRESULT QueryInterface(REFIID riid, VOID **ppvInterface);
 	HRESULT OnSessionCreated(IAudioSessionControl *NewSession);
+	void createSessionThread(SessionThreadParams params);
 	
 private:
+	std::atomic<bool> wait = false;
 	ULONG ref = 1;
 	EndpointHandler *eph;
+
+	struct SessionThreadParams {
+		EndpointHandler *eph;
+		Session *session;
+		bool isDelete;
+	};
+};
+
+namespace Environment {
+	wchar_t* getExeAbsPath(uint32_t *exeAbsPathLength);
+	std::string createSettingsPath(SettingsTargetDirectory target);
+	void populateSystemValues();
+	void openControlPanel();
+	ProcessedNativeEvent processTopLevelWindowMessage(void* msg);
+	ProcessedNativeEvent updateColors();
+	bool checkStartup(HKEY rootKeyFlags);
+	void updateStartupConfig(bool onStartup);
+	void setStartupConfig(bool onStartup);
+	bool isLightMode();
+	bool isToRunAtStartup();
+	uint32_t getAccentColor();
+
+	//todo: binary path cache unused
+	static std::wstring exeAbsPath;
+	static uint32_t exeAbsPathLen;
+	static bool lightMode;
+	static bool startup = false;
+	static HKEY scope;
+	static uint32_t accentColor;
 };
--- a/src/back/backsessionclasses.cpp
+++ b/src/back/backsessionclasses.cpp
@ -37,6 +37,9 @@ HRESULT SessionStateCallback::QueryInterface(REFIID riid, VOID **ppvInterface) {
 }

 HRESULT SessionStateCallback::OnDisplayNameChanged(LPCWSTR NewDisplayName, LPCGUID EventContext) {
+	//TODO: Preguntar
+	while(sh->getVolumeInfo()->isNameChanged == true);
+
    sh->setName(std::wstring(NewDisplayName));
 	sh->getVolumeInfo()->isNameChanged = true;
    return S_OK;
@ -91,8 +94,10 @@ HRESULT SessionStateCallback::OnStateChanged(AudioSessionState NewState) {
 }

 HRESULT SessionStateCallback::OnSessionDisconnected(AudioSessionDisconnectReason DisconnectReason) {
-	sh->setState(SessionState::DISCONNECTED);
-	sh->reviseSessionShowing(SessionState::DISCONNECTED);
+	if (DisconnectReason != DisconnectReasonDeviceRemoval) {
+		sh->setState(SessionState::DISCONNECTED);
+		sh->reviseSessionShowing(SessionState::DISCONNECTED);
+	}
    return S_OK;
 }

@ -126,10 +131,19 @@ Session::Session(Endpoint* ep, IAudioSessionControl2* sessionControl, size_t idx
 	else {
 		LPWSTR sessionDisplayName;
 		this->sessionControl->GetDisplayName(&sessionDisplayName);
-		if (!wcscmp(sessionDisplayName, L""))	
-		   	this->sessionName = this->fetchProcessName(pid);
-		else	
+		if (!wcscmp(sessionDisplayName, L"")) {
+			std::wstring exePath;
+			if (getExePath(pid, &exePath)) {
+				this->sessionName = exePath;
+				if (fetchName(exePath, pid)) goto nameFound;
+			}
+			if (fetchNameViaWindowName(pid, &this->sessionName)) goto nameFound;
+		} else { 	
 			this->sessionName = std::wstring(sessionDisplayName);
+			goto nameFound;
+		}
+		
+	nameFound:
 		CoTaskMemFree(sessionDisplayName);
 	}
 }
@ -192,87 +206,196 @@ void Session::setMute(NGuid guid, bool muted) {
 	if(FAILED(sessionVolume->SetMute(muted, &tempMsGuid))) { log_wdebugcpp(std::wstring(L"SessionVolume null?"));  };
 }

-std::wstring Session::fetchProcessName(DWORD pid) {
-	/*
-	 * https://learn.microsoft.com/en-us/windows/win32/api/tlhelp32/nf-tlhelp32-createtoolhelp32snapshot
-	 * https://stackoverflow.com/questions/11843368/how-to-get-process-description
-	 */
-	
-	/* Executable path retrieval  */
-	std::wstring exePath = L"";
-
-	HANDLE processList = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE | TH32CS_SNAPMODULE32, pid);
-	if (processList == INVALID_HANDLE_VALUE) {
-		log_wdebugcpp(L"aye no procname.");
-		return exePath;
+bool Session::getExePath(DWORD pid, std::wstring *exePath) {
+	//std::wstring msixName;
+	HANDLE processHandle;
+	wchar_t fileName[UNICODE_STRING_MAX_CHARS];
+	processHandle = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, pid);
+	if (processHandle != NULL) {
+		if (GetModuleFileNameEx(processHandle, NULL, fileName, UNICODE_STRING_MAX_CHARS) == 0) {
+			CloseHandle(processHandle);
+			return false;			 
+		}
+	} else {
+		log_wdebugcpp(L"aye no procname. -> " + std::to_wstring(GetLastError()));
+		return false;
 	}

-	MODULEENTRY32W me32w;
-    me32w.dwSize = sizeof(MODULEENTRY32W);
-    if(Module32FirstW(processList, &me32w)) {
-        do {
-			if (me32w.th32ProcessID == pid) {
-				exePath = std::wstring(me32w.szExePath);
-				break;
-				/*
-				 * However, if the calling process is a 32-bit process, you must call the
-				 * QueryFullProcessImageName function to retrieve the full path of the 
-				 * executable file for a 64-bit process.
-				 */
-			}
-        } while(Module32NextW(processList, &me32w));
-    }
-    CloseHandle(processList);
+	*exePath = std::wstring(fileName);
+	return true;
+}

-	/* File description retrieval */
+bool Session::fetchNameViaFD(std::wstring exePath, DWORD pid, std::wstring *sessionName) {
+	/* File description retrieval: size and available lang-codepages */
 	struct LANGANDCODEPAGE {
        WORD wLanguage;
        WORD wCodePage;
    } *translationArray;
 	
 	DWORD filler;
-	DWORD fileVersionInfoSize = GetFileVersionInfoSizeW(exePath.c_str(), &filler);
-	if (!fileVersionInfoSize) return exePath;
+	DWORD fileVersionInfoSize = GetFileVersionInfoSizeExW
+		(FILE_VER_GET_LOCALISED | FILE_VER_GET_NEUTRAL, exePath.c_str(), &filler);
+	if (!fileVersionInfoSize) return false;
 	
 	void* fileVersionInfo = malloc(fileVersionInfoSize);
-	if(!GetFileVersionInfoW(exePath.c_str(),0,fileVersionInfoSize, fileVersionInfo))
-		return exePath;
+	if(!GetFileVersionInfoExW(FILE_VER_GET_LOCALISED | FILE_VER_GET_NEUTRAL,
+							  exePath.c_str(),0,fileVersionInfoSize, fileVersionInfo)) {
+		return false;
+	}

 	UINT translationArrayLen = 0;
-	if (!VerQueryValueW(fileVersionInfo, L"\\VarFileInfo\\Translation", (LPVOID*)&translationArray, &translationArrayLen))
-		return exePath;
+	if (!VerQueryValueW(fileVersionInfo, L"\\VarFileInfo\\Translation", (LPVOID*)&translationArray, &translationArrayLen)) {
+		free(fileVersionInfo);
+		return false;
+	}
+	//File descriptor parsing
+	//TODO: https://learn.microsoft.com/en-us/windows/win32/api/winnls/nf-winnls-getuserpreferreduilanguages
+	/* It is possible to retrieve user languages and try to use one of those before falling back to whatever
+	 * is available. Also possible to hardcode en-US or any other lang-codepage combo. When an actual translation
+	 * sysem is put in place, I'll come finish this up.
+	 */
+	uint64_t availableLangs = (translationArrayLen / sizeof(LANGANDCODEPAGE));
+	if (!availableLangs) { free(fileVersionInfo); return false; }

-	bool match = false;
-	 for (UINT i = 0; i < (translationArrayLen / sizeof(LANGANDCODEPAGE)); i++) {
-        wchar_t fileDescriptionKey[256];
+	int8_t syslangIdx = -1;
+	wchar_t metadataStringKey[256];
+	wchar_t* metadataString = NULL;
+	for (UINT i = 0; i < availableLangs; i++) {  
 		LANGID defaultUILanguage = GetUserDefaultUILanguage();
        if (defaultUILanguage != translationArray[i].wLanguage)
 			continue;

-		match = true;
-        wchar_t* fileDescription = NULL;
-        UINT fileDescriptionSize = 0;
-		 swprintf(fileDescriptionKey, L"\\StringFileInfo\\%04x%04x\\FileDescription",
-            translationArray[i].wLanguage, translationArray[i].wCodePage);
-        if (VerQueryValueW(fileVersionInfo, fileDescriptionKey, (LPVOID*)&fileDescription, &fileDescriptionSize)) {
-            exePath = std::wstring(fileDescription);
-        }
+		syslangIdx = i;
+		break;
    }

-	 if (!match && 1 <= (translationArrayLen / sizeof(LANGANDCODEPAGE))) {
-		  wchar_t fileDescriptionKey[256];
+	UINT metadataStringSize = 0;
+	swprintf(metadataStringKey, L"\\StringFileInfo\\%04x%04x\\FileDescription",
+			 translationArray[(syslangIdx < 0 ? 0 : syslangIdx)].wLanguage,
+			 translationArray[(syslangIdx < 0 ? 0 : syslangIdx)].wCodePage);
+	if (VerQueryValueW(fileVersionInfo, metadataStringKey, (LPVOID*)&metadataString, &metadataStringSize)
+		&& metadataString[0] != '\0') {
+		free(fileVersionInfo);
+		*sessionName = std::wstring(metadataString);
+		return true;
+	}
+	swprintf(metadataStringKey, L"\\StringFileInfo\\%04x%04x\\ProductName",
+			 translationArray[(syslangIdx < 0 ? 0 : syslangIdx)].wLanguage,
+			 translationArray[(syslangIdx < 0 ? 0 : syslangIdx)].wCodePage);
+	if (VerQueryValueW(fileVersionInfo, metadataStringKey, (LPVOID*)&metadataString, &metadataStringSize)
+		&& metadataString[0] != '\0') {
+		free(fileVersionInfo);
+		*sessionName = std::wstring(metadataString);
+		return true;
+	}

-wchar_t* fileDescription = NULL;
-        UINT fileDescriptionSize = 0;
-		 swprintf(fileDescriptionKey, L"\\StringFileInfo\\%04x%04x\\FileDescription",
-            translationArray[0].wLanguage, translationArray[0].wCodePage);
-        if (VerQueryValueW(fileVersionInfo, fileDescriptionKey, (LPVOID*)&fileDescription, &fileDescriptionSize)) {
-            exePath = std::wstring(fileDescription);
-        }
-	 }
+	if(fileVersionInfo)
+		free(fileVersionInfo);
+
+	return false;
+}
+
+
+bool Session::fetchNameViaMSIX(std::wstring exePath, DWORD pid, std::wstring *sessionName) {
+	HANDLE process = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, FALSE, pid);
+	if(!process) return false;
+
+	//constant missing in mingw64. TB removed when I upgrade to a mingw64 ver that has it
+	#define APPLICATION_USER_MODEL_ID_MAX_LENGTH 130
+	uint32_t length = APPLICATION_USER_MODEL_ID_MAX_LENGTH;
+	PWSTR userModelId = (PWSTR)malloc(length * sizeof(wchar_t));
+	if(GetApplicationUserModelId(process, &length, userModelId) != ERROR_SUCCESS) {
+		CloseHandle(process);
+		return false;
+	}
+	CloseHandle(process);
+
+	static constexpr wchar_t* prefix = L"shell:appsfolder\\";
+	uint32_t prefixLen = wcslen(prefix);
+	uint32_t userModelIdLen = wcslen(userModelId);
+	wchar_t* fullName;
+	fullName = (prefixLen + userModelIdLen < length)
+		? (wchar_t*)malloc(length * sizeof(wchar_t))
+	    : (wchar_t*)malloc((length * 2) * sizeof(wchar_t));
+	for (int32_t i = prefixLen - 1; i >= 0; i--) {
+		fullName[i] = prefix[i];
+	}	
+	for (uint32_t i = 0; i < userModelIdLen + 1; i++) {
+		fullName[prefixLen + i] = userModelId[i];
+	}
+		
+	IShellItem* si;
+	HRESULT hr = SHCreateItemFromParsingName(fullName,
+								nullptr,
+								IID_IShellItem,
+								(void**)&si
+								);
+	free(fullName);
+	LPWSTR humanName = nullptr;
+	si->GetDisplayName(SIGDN_NORMALDISPLAY, &humanName);
+	if(humanName && humanName[0] != '\0') {
+		*sessionName = std::wstring(humanName);
+		CoTaskMemFree(humanName);
+	}
+	if(si) si->Release();
+
+	if (sessionName->length() > 0) 
+		 return true;
+	else return false;
+}
+
+
+bool Session::fetchNameViaWindowName(DWORD pid, std::wstring *sessionName) {
+	//lParam is documented as in, so... Beware of future explosions, ig?
+	std::pair<HWND, DWORD> params = { 0, pid };
+	
+    BOOL result = EnumWindows([](HWND hwnd, LPARAM lParam) -> BOOL {
+		auto pParams = (std::pair<HWND, DWORD>*)(lParam);
+	
+		DWORD processId;
+		//IsWindowVisible(hwnd) &&&& GetWindow(hwnd, GW_OWNER) == 0
+		if ( GetWindowThreadProcessId(hwnd, &processId) && processId == pParams->second) {
+			int length = GetWindowTextLength(hwnd);
+			if (!length) return TRUE;
+			
+			// Stop enumerating
+			SetLastError(-1);
+			pParams->first = hwnd;
+			return FALSE;
+		}
+	
+		// Continue enumerating
+		return TRUE;
+	} , (LPARAM)&params);
+
+	if(!result && GetLastError() == -1 && params.first) {
+		//todo: double-dipping length... Not a fan
+		int length = GetWindowTextLength(params.first);
+		wchar_t* buffer = new wchar_t[length + 1];
+		GetWindowTextW(params.first, buffer, length + 1);
+		*sessionName = buffer;
+		delete[] buffer;
+		return true;
+	} 
+	return false;
+}
+
+bool Session::fetchName(std::wstring exePath, DWORD pid) {
+	/*
+	 * if(fetchNameViaWindowName(exePath, pid, &this->sessionName))
+	 * 	return;
+	 * else if(fetchNameViaMSIX(exePath, pid, &this->sessionName))
+	 * 	return;
+	 * else if(!fetchNameViaFD(exePath, pid, &this->sessionName))
+	 * 	this->sessionName = exePath;
+	 */
+
+	if(fetchNameViaFD(exePath, pid, &this->sessionName))
+		return true;
+	return fetchNameViaMSIX(exePath, pid, &this->sessionName);
+	//else if(!fetchNameViaWindowName(exePath, pid, &this->sessionName))
+	///	this->sessionName = exePath;

-    free(fileVersionInfo);
-	return exePath;
 }

 //todo: conflicting names. change callback name
@ -296,4 +419,7 @@ Session::~Session() {
 	meterInformation->Release();
 	sessionControl->Release();
 	sessionVolume->Release();
+	meterInformation = nullptr;
+	sessionControl	 = nullptr;
+	sessionVolume	 = nullptr;
 }
--- a/src/back/backsessionclasses.h
+++ b/src/back/backsessionclasses.h
@ -47,13 +47,18 @@ class Session {
 	//uint32_t getChannelCount();
 	
 private:
-	std::wstring fetchProcessName(DWORD pid);
+    bool getExePath(DWORD pid, /*out*/ std::wstring *exePath);
+	bool fetchName(std::wstring exePath, DWORD pid);
+	bool fetchNameViaFD(std::wstring exePath, DWORD pid, /*out*/ std::wstring *sessionName);
+	bool fetchNameViaMSIX(std::wstring exePath, DWORD pid, /*out*/ std::wstring *sessionName);
+	bool fetchNameViaWindowName(DWORD pid, /*out*/ std::wstring *sessionName);
+	/* std::wstring fetchProcessName(DWORD pid); */
 	std::wstring sessionName;
 	SessionState sessionState;
 	Endpoint* ep;
 	IAudioSessionControl2* sessionControl = nullptr;
 	IAudioMeterInformation* meterInformation = nullptr;
 	ISimpleAudioVolume* sessionVolume = nullptr;
-	size_t idx;
+	size_t idx; 
 };

--- a/src/back/msinclude.h
+++ b/src/back/msinclude.h
@ -1,12 +1,15 @@
 #pragma once

-#define _WIN32_WINNT 0x0A00
 #include <sdkddkver.h>

 //done by qt by def #define UNICODE

 #include <Windows.h>
 #include <shellapi.h>
+#include <Shobjidl.h>
+#include <Shlobj.h>
+#include <fileapi.h>
+#include <appmodel.h>
 #include <processthreadsapi.h>
 #include <mmdeviceapi.h>
 #include <combaseapi.h>
@ -14,6 +17,7 @@
 #include <Propidl.h>
 #include <propsys.h>
 #include <functiondiscoverykeys_devpkey.h>
+#include <psapi.h>
 //#include <debugapi.h>

 #include <endpointvolume.h>
@ -25,6 +29,7 @@
 #include <stringapiset.h>
 #include <Mmreg.h>
 #include <tlhelp32.h>
+#include <Knownfolders.h>

 #include "ipolicyconfig.h"
 #include "audiometerinfo.h"
--- a/src/cont/contclasses.cpp
+++ b/src/cont/contclasses.cpp
@ -1,27 +1,37 @@
 #include "backlasses.h"
 #include "contclasses.h"
-//TODO: pragma once
+
+void setConfigDirToDefaults() {    
+    #define tryFileDir(dir, create) do {             \
+		OverseerHandler::settingsPath = Environment::createSettingsPath(dir); \
+        set = ini::UserSettings::createSettings(OverseerHandler::settingsPath.c_str(), create); \
+        if(set) { \ 
+            return;                                        \
+		} else OverseerHandler::settingsPath.clear();			   \
+    } while(0)
+    #define tryOpenFileDir(dir) tryFileDir(dir, false)      
+    #define tryCreateFileDir(dir) tryFileDir(dir, true)
+    
+    tryOpenFileDir(SettingsTargetDirectory::APP_PATH);  
+    tryOpenFileDir(SettingsTargetDirectory::HOME_DIR);  
+    tryCreateFileDir(SettingsTargetDirectory::HOME_DIR);  
+    tryCreateFileDir(SettingsTargetDirectory::APP_PATH);  
+    
+	return;
+	#undef tryOpenFileDir
+	#undef tryCreateFileDir
+	#undef tryFileDir
+}

 EndpointHandler::EndpointHandler(uint64_t idx, Flows flow) {
-	//std::vector<Endpoint*> endpoints = osh->getPlaybackEndpoints().at(idx);
 	this->idx = idx;
 	this->flow = flow;
 	this->ep = (flow == Flows::FLOW_PLAYBACK ? osh->getPlaybackEndpoints().at(idx) : osh->getCaptureEndpoints().at(idx));
 		
-	epc = new EndpointVolumeCallback(ep);
-	ensc = new EndpointNewSessionCallback(this);
 	this->callbackInfo.caller = osh->getGuid();
-	ep->registerNewSessionNotification(ensc);
 	//epName = ep->getName();
 	this->setBackEndpointVolumeCallbackInfoContent(this->getState()); 
 	osh->pushBackEndpointHandler(this, flow);
-	
-	 if (this->flow == Flows::FLOW_PLAYBACK) {
-	 	for (int i = 0; i < this->getSessionCount(); i++) {
-	  		SessionHandler* sessionHandler = new SessionHandler(this, this->getSessions().at(i),i);
-			sessionHandlers.push_back(sessionHandler);
-	  	}
-	  } 
 }

 void OverseerHandler::pushBackEndpointHandler(EndpointHandler* eph, Flows flow) {
@ -50,16 +60,6 @@ Flows EndpointHandler::getFlow(){
 	return ep->getFlow();
 }

-/* 	these two, currently unused. If I use them, I should feel bad.
- * Endpoint* EndpointHandler::getEndpoint() {
- * 	return this->ep;
- * }
- * 
- * EndpointVolumeCallback* EndpointHandler::getEndpointVolumeCallback() {
- * 	return this->epc;
- * }
- */
-
 BackEndpointVolumeCallbackInfo* EndpointHandler::getCallbackInfo(){
 	return &this->callbackInfo;
 }
@ -114,7 +114,10 @@ void EndpointHandler::setBackEndpointVolumeCallbackInfoContent(uint8_t state) {
 		callbackInfo.muted = this->getMute();
 		callbackInfo.mainVolume = this->getVolume(AudioChannel::CHANNEL_MAIN);
 		callbackInfo.channels = this->getChannelCount();
-		ep->setVolumeCallback(epc);
+		if (!epc) {
+			epc = new EndpointVolumeCallback(ep);
+			ep->setVolumeCallback(epc);
+		}
 		callbackInfo.channelVolumes.resize(this->callbackInfo.channels);
 		for(uint32_t i = 0; i < this->getChannelCount(); i++){
 			callbackInfo.channelVolumes.at(i) = this->getVolume(i);
@ -122,12 +125,12 @@ void EndpointHandler::setBackEndpointVolumeCallbackInfoContent(uint8_t state) {
 	}
 }	

-void EndpointHandler::setState(uint8_t state){
+void EndpointHandler::setState(EndpointState state){
 	ep->setState(state);
 	this->setBackEndpointVolumeCallbackInfoContent(state);
 }

-void EndpointHandler::setState(uint8_t state, uint64_t index){
+void EndpointHandler::setState(EndpointState state, uint64_t index){
 	ep->setState(state);
 	this->setFrontVisibilityInfo((EndpointState)state, index);	
 	this->setBackEndpointVolumeCallbackInfoContent(state);
@ -179,10 +182,15 @@ Endpoint* EndpointHandler::getEndpoint() {
 }

 void EndpointHandler::addSessionSendFront(Session* session) {
-	ep->addSession(session);
-
+	if(!ep->endpointSessionsMutex.try_lock()) return;
+	sessionHandlersMutex.lock();
+	
+	this->ep->addSession(session);
  	SessionHandler* sessionHandler = new SessionHandler(this, session, (getSessionCount() - 1));
+	
 	sessionHandlers.push_back(sessionHandler);
+	ep->endpointSessionsMutex.unlock();
+	sessionHandlersMutex.unlock();
 	this->addSessionWidget(sessionHandler);
 }

@ -194,6 +202,49 @@ void EndpointHandler::removeSessionFromFront(SessionHandler* sh) {
 	this->removeSessionWidget(sh);
 }

+void EndpointHandler::deleteSessions() {
+	ep->unregisterNewSessionNotification(ensc);
+	ensc->Release();
+	ensc = nullptr;
+	for (auto sh : sessionHandlers) {
+		delete sh;
+	}
+	sessionHandlers.resize(0);
+	ep->deleteSessions();
+	//ep->deleteSessionManager();
+}
+
+void EndpointHandler::createSessionHandlers() {
+	ep->activateEndpointSessions();
+	if (this->flow == Flows::FLOW_PLAYBACK) {
+	 	for (int i = 0; i < this->getSessionCount(); i++) {
+	  		SessionHandler* sessionHandler = new SessionHandler(this, this->getSessions().at(i),i);
+			sessionHandlers.push_back(sessionHandler);
+	  	}
+	}
+}
+
+void EndpointHandler::createSessionHandlersCallback() {
+	ensc = new EndpointNewSessionCallback(this);
+	ep->registerNewSessionNotification(ensc);
+}
+
+void EndpointHandler::lockSessionCollections() {
+	this->sessionHandlersMutex.lock();
+	this->ep->endpointSessionsMutex.lock();
+}
+
+void EndpointHandler::unlockSessionCollections() {
+	this->sessionHandlersMutex.unlock();
+	this->ep->endpointSessionsMutex.unlock();
+}
+
+void EndpointHandler::removeVolumeCallback() {
+	ep->removeVolumeCallback(epc);
+	epc->Release();
+	epc = nullptr;
+}
+
 EndpointHandler::~EndpointHandler() {
 	ep->removeVolumeCallback(epc);
 	ep->unregisterNewSessionNotification(ensc);
@ -205,8 +256,44 @@ OverseerHandler::OverseerHandler() {
 	this->os = new Overseer();
 }

+void OverseerHandler::setSettingsPath(std::string path) {
+	OverseerHandler::settingsPath = path;
+}
+
+std::string OverseerHandler::getSettingsPath(){
+	return OverseerHandler::settingsPath;
+}
+
+void OverseerHandler::updateStartupConfig(bool onStartup) {
+	Environment::updateStartupConfig(onStartup);
+}
+
+void OverseerHandler::setStartupConfig(bool onStartup) {
+	Environment::setStartupConfig(onStartup);
+}
+
+void OverseerHandler::populateSystemValues() {
+	Environment::populateSystemValues();
+}
+
 void OverseerHandler::openControlPanel() {
-	this->os->openControlPanel(); 
+	Environment::openControlPanel();
+}
+
+ProcessedNativeEvent OverseerHandler::processTopLevelWindowMessage(void* msg) {
+	return Environment::processTopLevelWindowMessage(msg);
+}
+
+bool OverseerHandler::isLightMode() {
+	return Environment::isLightMode();
+}
+
+bool OverseerHandler::isToRunAtStartup() {
+	return Environment::isToRunAtStartup();
+}
+
+uint32_t OverseerHandler::getAccentColor() {
+	return Environment::getAccentColor();
 }

 std::vector<Endpoint*> OverseerHandler::getPlaybackEndpoints() {
@ -233,7 +320,7 @@ uint64_t OverseerHandler::getCaptureEndpointsCount(){
 	return this->os->getCaptureEndpoints().size();
 }

-void OverseerHandler::reloadEndpointHandlers(){
+void OverseerHandler::createEndpointHandlers(){
 	//todo: add capture
 	
 	//std::vector<EndpointHandler*>* ephs = new std::vector<EndpointHandler*>;
@ -241,9 +328,7 @@ void OverseerHandler::reloadEndpointHandlers(){
 	
 	for(uint64_t i = 0; i < this->getPlaybackEndpointsCount(); i++){
 		log_debugcpp("Creating Playback handler " + std::to_string(i));
-				
-		EndpointHandler* ephexx = new EndpointHandler(i, Flows::FLOW_PLAYBACK);
-		//this->playbackEndpointHandlers.push_back(ephexx);
+		new EndpointHandler(i, Flows::FLOW_PLAYBACK);
 		log_debugcpp("Created Playback  handler " + std::to_string(i) + ", adding to vector. " + " VSize: " + std::to_string(this->playbackEndpointHandlers.size()));
 		
 	}
@ -251,51 +336,55 @@ void OverseerHandler::reloadEndpointHandlers(){
 	log_debugcpp("Capture VSize: " +
 				 std::to_string(this->getCaptureEndpointsCount()));
 	
-	for(uint64_t i = 0; i < this->getCaptureEndpointsCount(); i++){
+	for(uint64_t i = 0; i < this->getCaptureEndpointsCount(); i++) {
 		log_debugcpp("Creating Capture handler " + std::to_string(i));
-		
-		/*
-		 * if(i < (this->captureEndpointHandlers.size()) && 
-		 *    this->captureEndpointHandlers.at(i) != nullptr)
-		 * 	delete captureEndpointHandlers.at(i);
-		 */
-		
-		EndpointHandler* ephoo = new EndpointHandler(i, Flows::FLOW_CAPTURE);		
-		//this->captureEndpointHandlers.push_back(ephoo);
+		new EndpointHandler(i, Flows::FLOW_CAPTURE);
 		log_debugcpp("Created Capture handler " + std::to_string(i) + ", adding to vector. " + " VSize: " + std::to_string(this->captureEndpointHandlers.size()));
-
 		/*
 		 * if (i >= this->captureEndpointHandlers.size())
 		 * 	captureEndpointHandlers.push_back(eph);
 		 * else captureEndpointHandlers.at(i) = eph;
 		 */
 	}
-	//setEndpointHandlers(ephs);
+	os->registerEndpointSituationCallback();
 }

-EndpointHandler* OverseerHandler::addEndpoint(std::wstring endpointId, /* out */ Flows *flow = nullptr){
+EndpointHandler* OverseerHandler::addEndpoint(std::wstring endpointId, /* out */ Flows *flow = nullptr) {
+	//This method is only called from the new endpoint callback and its subsequent thread
 	Flows localFlow;
 	Endpoint* newEp = this->os->addEndpoint(endpointId, &localFlow);

 	uint64_t ephIdx = (localFlow == Flows::FLOW_PLAYBACK ? this->getPlaybackEndpointsCount() : this->getCaptureEndpointsCount()) - 1;

 	EndpointHandler* newEph = new EndpointHandler(ephIdx, localFlow);
-	//	std::vector<EndpointHandler*> getPlaybackEndpointHandlers();
-	//std::vector<EndpointHandler*> getCaptureEndpointHandlers();
 	if (flow != nullptr) *flow = localFlow;
 	return newEph;
 }

+void OverseerHandler::reportFinishedStateChange() {
+	os->reportFinishedStateChange();
+}
+
 NGuid OverseerHandler::getGuid() {
 	return this->os->getGuid();
 }

-void OverseerHandler::setChangeFrontDefaultsFunction(std::function<void(Roles, std::wstring)> changeFrontDefaults){
-	this->changeFrontDefaults = changeFrontDefaults;
+/*
+ * void OverseerHandler::setChangeFrontDefaultsFunction(std::function<void(Roles, std::wstring)> changeFrontDefaults){
+ * 	this->changeFrontDefaults = changeFrontDefaults;
+ * }
+ * 
+ * void OverseerHandler::changeFrontDefaultsCallback(Roles role, std::wstring endpointId) {
+ * 	this->changeFrontDefaults(role, endpointId);
+ * }
+ */
+
+void OverseerHandler::roleBucketEntryCallback(Roles role, std::wstring endpointId){
+	this->roleBucketEntry(role, endpointId);
 }

-void OverseerHandler::changeFrontDefaultsCallback(Roles role, std::wstring endpointId) {
-	this->changeFrontDefaults(role, endpointId);
+void OverseerHandler::setRoleBucketEntryFunction(std::function<void(Roles, std::wstring)> roleBucketEntry) {
+	this->roleBucketEntry = roleBucketEntry;
 }

 void OverseerHandler::updateFrontEndpointName(Endpoint* ep) {
@ -306,7 +395,12 @@ void OverseerHandler::updateFrontEndpointName(Endpoint* ep) {
 }

 void OverseerHandler::reviseEndpointShowing(std::wstring endpointId, EndpointState state) {
+	//TODO: Race condition!!!!!
 	std::vector<EndpointHandler*> allHandlers;
+	handlersPlaybackMutex.lock();
+	handlersCaptureMutex.lock();
+	os->playbackMutex.lock();
+	os->captureMutex.lock();
 	allHandlers.insert(allHandlers.end(), this->captureEndpointHandlers.begin(), this->captureEndpointHandlers.end());
 	allHandlers.insert(allHandlers.end(), this->playbackEndpointHandlers.begin(), this->playbackEndpointHandlers.end());
 	EndpointHandler* eph = nullptr;
@ -320,20 +414,29 @@ void OverseerHandler::reviseEndpointShowing(std::wstring endpointId, EndpointSta
 	//debug
 	Flows flow; 
 	if (!eph) {
-		if (state ^ EndpointState::ENDPOINT_ACTIVE) return;
+		if (state ^ EndpointState::ENDPOINT_ACTIVE) goto end;
 		//flow = Flows::FLOW_CAPTURE;
 		eph = osh->addEndpoint(endpointId, &flow);
 	} else
 		flow = eph->getFlow();

 	//todo: mic done but disabled. Tab-kun will come...
-	if (flow == Flows::FLOW_CAPTURE) return;
+	if (flow == Flows::FLOW_CAPTURE) goto end;

-	if(eph && EndpointState::ENDPOINT_ACTIVE & state) {
+	if (eph && EndpointState::ENDPOINT_ACTIVE & state) {
+		eph->setState(EndpointState::ENDPOINT_ACTIVE);
 		this->addEndpointWidget(eph);
-	} else if (eph && eph->getFrontVisibilityState() == EndpointState::ENDPOINT_ACTIVE){
+	} else if (eph && eph->getFrontVisibilityState() == EndpointState::ENDPOINT_ACTIVE) {
+		eph->removeVolumeCallback();
 		this->removeEndpointWidget(eph->getFrontVisibilityIndex());
 	}
+
+ end:
+	handlersPlaybackMutex.unlock();
+	handlersCaptureMutex.unlock();
+	os->playbackMutex.unlock();
+	os->captureMutex.unlock();
+	os->reportFinishedStateChange();
 	return;
 }

@ -348,3 +451,14 @@ void OverseerHandler::setRemoveEndpointWidgetFunction(std::function<void(uint64_
 void OverseerHandler::setEndpointHandlers(std::vector<EndpointHandler*> ephs){
 	this->playbackEndpointHandlers = ephs;
 }
+
+void OverseerHandler::lockEndpoints() {
+	os->playbackMutex.lock();
+	os->captureMutex.lock();
+}
+
+void OverseerHandler::unlockEndpoints() {
+	os->playbackMutex.unlock();
+	os->captureMutex.unlock();
+}
+
--- a/src/cont/contclasses.h
+++ b/src/cont/contclasses.h
@ -1,6 +1,7 @@
 #pragma once

 #include "global.h"
+#include "settings.h"
 #include "contsessionclasses.h"
 //#define invoke_mem_fn(object,ptrToMember)  ((object).*(ptrToMember))
 //#define pinvoke_mem_fn(object,ptrToMember)  ((object)->*(ptrToMember))
@ -16,11 +17,13 @@ struct BackEndpointVolumeCallbackInfo {
 	NGuid caller;
 	bool  muted;
 	float mainVolume;
-	size_t  channels;
+	size_t channels;
 	std::vector<float> channelVolumes;
 	bool updateName = false;
 };

+void setConfigDirToDefaults();
+
 class EndpointHandler {
 	
 public:
@ -55,8 +58,8 @@ public:
 	
 	void setVolume(NGuid guid, int channel, int value);
 	void setMute(NGuid guid, bool muted);
-	void setState(uint8_t state);
-	void setState(uint8_t state, uint64_t idx);
+	void setState(EndpointState state);
+	void setState(EndpointState state, uint64_t idx);

 	float getPeakVolume();
 	/* sessions */
@ -71,6 +74,13 @@ public:
 	void setRemoveSessionWidgetFunction(std::function<void(SessionHandler*)> removeSessionWidget);
 	void sendSessionToFront(SessionHandler* sh);
 	void removeSessionFromFront(SessionHandler* sh);
+	void deleteSessions();
+	void createSessionHandlers();
+	void createSessionHandlersCallback();
+	std::mutex sessionHandlersMutex;
+	void lockSessionCollections();
+	void unlockSessionCollections();
+	void removeVolumeCallback();
 	
 	~EndpointHandler();
 private:
@ -97,11 +107,24 @@ class OverseerHandler {

 public:
 	OverseerHandler();
+	static void setSettingsPath(std::string path);
+	static std::string getSettingsPath();
+	static inline std::string settingsPath;
+	void updateStartupConfig(bool onStartup);
+	void setStartupConfig(bool onStartup);
+	void populateSystemValues();
 	void openControlPanel();
+	ProcessedNativeEvent processTopLevelWindowMessage(void* msg);
+	bool isLightMode();
+	bool isToRunAtStartup();
+	uint32_t getAccentColor();
 	
-	void setChangeFrontDefaultsFunction(std::function<void(Roles, std::wstring)> changeFrontDefaults);
-	void changeFrontDefaultsCallback(Roles role, std::wstring endpointId);
+	//void setChangeFrontDefaultsFunction(std::function<void(Roles, std::wstring)> changeFrontDefaults);
+	//void changeFrontDefaultsCallback(Roles role, std::wstring endpointId);

+	void roleBucketEntryCallback(Roles role, std::wstring endpointId);
+	void setRoleBucketEntryFunction(std::function<void(Roles, std::wstring)> roleBucketEntry);
+	
 	void updateFrontEndpointName(Endpoint* ep);
 	//void setReviseEndpointShowingFunction(std::function<void(std::wstring, EndpointState)> reviseEndpointShowing);
 	void reviseEndpointShowing(std::wstring endpointId, EndpointState state);
@ -116,25 +139,29 @@ public:
 	void pushBackEndpointHandler(EndpointHandler* eph, Flows flow);
 	uint64_t getPlaybackEndpointsCount();
 	uint64_t getCaptureEndpointsCount();
-	void reloadEndpointHandlers();
-	EndpointHandler* addEndpoint(std::wstring endpointId, Flows *flow); 
+	void createEndpointHandlers();
+	EndpointHandler* addEndpoint(std::wstring endpointId, Flows *flow);
+	void reportFinishedStateChange();
 	NGuid getGuid();

-	/*
-	 * void setSessionVolumeCallback(std::function<void(float)> changeSessionVolume);
-	 * void setSessionVolume(float newValue, ); 
-	 */
+	std::mutex handlersPlaybackMutex;
+	std::mutex handlersCaptureMutex;
+	void lockEndpoints();
+	void unlockEndpoints();
 	
 private:
    Overseer *os;
 	std::vector<EndpointHandler*> playbackEndpointHandlers;
 	std::vector<EndpointHandler*> captureEndpointHandlers;
+
 	std::function<void(Roles, std::wstring /* endpointid */)> changeFrontDefaults;
 	std::function<void(uint64_t /* epw id */)> removeEndpointWidget;
 	std::function<void(EndpointHandler*)> addEndpointWidget;
-
+	std::function<void(Roles, std::wstring /* endpointid */)> roleBucketEntry;
+	
 	/* Session's */
 	std::function<void(float)> changeSessionVolume;
+	
 	//std::function<void(uint64_t /* device */, uint32_t /* channel */, float /* value */)> updateFrontVolumeCallback;
 	//std::function<void(uint64_t /* device */, bool /* mute */)> updateFrontMuteCallback;
 	
--- a/src/cont/contsessionclasses.cpp
+++ b/src/cont/contsessionclasses.cpp
@ -5,7 +5,7 @@ SessionHandler::SessionHandler(EndpointHandler* eph, Session* session, size_t id
 	this->eph = eph;
 	this->idx = idx;
 	this->session = session;
-
+	
 	this->svi.mainVolume = session->getVolume(AudioChannel::CHANNEL_MAIN);
 	this->svi.muted = session->getMute();
 	this->svi.caller = osh->getGuid();
@ -85,3 +85,7 @@ void SessionHandler::reviseSessionShowing(SessionState state) {
 	}
 }

+SessionHandler::~SessionHandler() {
+	session->removeStateCallback(ssc);
+	ssc->Release();
+}
--- a/src/cont/contsessionclasses.h
+++ b/src/cont/contsessionclasses.h
@ -9,10 +9,10 @@ class SessionStateCallback;

 struct SessionVolumeInfo {
 	//SessionVolumeInfo(bool muted, float mainVolume);
-	bool  muted;
-	float mainVolume;
-	NGuid caller;
-	bool isNameChanged = false;
+	bool 			  muted;
+	float			  mainVolume;
+	NGuid			  caller;
+	std::atomic<bool> isNameChanged = false;
 	//size_t  channels;
 	//std::vector<float> channelVolumes;
 };
@ -33,7 +33,7 @@ class SessionHandler {
 	void setName(std::wstring newName);
 	void reviseSessionShowing(SessionState state);
 	SessionVolumeInfo* getVolumeInfo();
-	
+	~SessionHandler();
 private:
 	SessionVolumeInfo svi;
 	EndpointHandler* eph;
--- a/src/debug.h
+++ b/src/debug.h
@ -2,6 +2,8 @@

 #if defined (QT_DEBUG) || defined (DEBUG) || defined (_DEBUG)

+#define PIPE_NAME "Mixerq-dev"
+
 #ifdef INIT_FILELOG
    std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t> converter;
 	FILE* fileLog;
@ -56,7 +58,7 @@ std::bitset<sizeof(T) * 8> varToBitset(T info) {
 		OutputDebugStringW(std::wstring(L"[DEBUG] (" +  std::wstring(WFILE) + L":" + std::to_wstring(__LINE__) + L"): " + std::wstring(str) +L"\n").c_str()); \
 	} while (0)

-#endif
+#endif //_WIN32

 #define log_to_file(fmt, cnt...)  do {				\
 	if(writable) fprintf_s(fileLog, fmt,##cnt); 	\
@ -72,8 +74,9 @@ std::bitset<sizeof(T) * 8> varToBitset(T info) {
 #define print_as_binary(info)
 #define log_to_file(fmt, cnt...)
 #define initialize_file_log() false
-#define close_file_log_buffer() 
-#endif
+#define close_file_log_buffer()
+#define PIPE_NAME "Mixerq"
+#endif //DEBUG

 /* Here as a quick reference, in case smthn similar is needed again */
 /* typedef void (EndpointWidget::*epwMuteFunc)(bool muted); */
--- a/src/global.h
+++ b/src/global.h
@ -10,10 +10,17 @@
 #include <string>
 #include <bitset>
 #include <locale>
+#include <map>
+#include <thread>
+#include <deque>

 #include "debug.h"
+//#include "settings.h"

 //TODO: Use tr();? QTranslator
+#define APP_NAME "MixerQ"
+#define LAPP_NAME L"MixerQ"
+
 #define STRING_MUTE "Mute"
 #define STRING_UNMUTE "Unmute"
 #define STRING_QUIT "Quit"
@ -30,8 +37,25 @@
 #define STRING_CP "Open Control Panel"
 #define STRING_ABOUT "About"
 #define STRING_STARTUP "Run at startup"
+#define STRING_CHANNELS "Show endpoint channels"
+
+#define STRING_NOENDPOINT "No active endpoints"
+
+#define LSTRING_UNNAMED_SESSION L"Unnamed session"
+
 //INIT BACK

+enum SettingsTargetDirectory {
+	HOME_DIR = 0,
+	APP_PATH = (1 << 0),
+	CUSTOM   = (1 << 1),
+};
+
+enum ProcessedNativeEvent {
+	NONE   = 0,
+	COLORS = (1 << 0),
+};
+
 enum AudioChannel {
 	CHANNEL_LEFT  = (1 << 0),
 	CHANNEL_RIGHT = (1 << 1),
@ -83,7 +107,11 @@ struct NGuid {
 	/* 	}while (i < 8); */
 	/* } */
 };
+namespace ini {
+	class UserSettings;
+}

+extern ini::UserSettings *set;
 class OverseerHandler;
 extern OverseerHandler *osh;

--- a/src/qt/meterslider.h
+++ b/src/qt/meterslider.h
@ -0,0 +1,19 @@
+#include <QSlider>
+
+class MeterSlider : public QSlider {
+	Q_OBJECT
+private:
+	~MeterSlider();
+	float peakValue;
+	
+	friend class MixerStyle;
+protected:
+	bool event(QEvent* ev) override;
+	void paintEvent(QPaintEvent *event) override;
+	
+public:
+	//MeterSlider(Qt::Orientation orientation, QWidget *parent = nullptr);
+	//MeterSlider(QWidget* parent = nullptr) : MeterSlider(Qt::Vertical, parent){};
+	void setPeakValue(float peakValue);
+	using QSlider::QSlider;
+};
--- a/src/qt/qtclasses.cpp
+++ b/src/qt/qtclasses.cpp
--- a/src/qt/qtclasses.h
+++ b/src/qt/qtclasses.h
@ -1,52 +1,10 @@
 #pragma once

-//#ifndef MAINWINDOW_H
-//#define MAINWINDOW_H
-
-#include <QMainWindow>
-#include <QApplication>
-#include <QCloseEvent>
-
-#include <QIcon>
-#include <QSystemTrayIcon>
-#include <QMenu>
-//#include <QMessageBox>
-
-#include <QLabel>
-#include <QSlider>
-#include <QGridLayout>
-#include <QPushButton>
-#include <QCheckBox>
-#include <QTimer>
-#include <QScrollArea>
-#include <QScrollBar>
-#include <QSize>
-#include <QMenuBar>
-#include <QMenu>
-#include <QScreen>
-#include <QToolBar>
-#include <QWindow>
-#include <QPainter>
-#include <QStyle>
-#include <QStyleOptionComplex>
-#include <QStyleOptionSlider>
-#include <QStylePainter>
-#include <QStyleOptionSlider>
-
-//#include <QScrollBar>
-/*
- * #else
- * class QSlider;
- * class QLabel;
- * class QGridLayout;
- * class QPushButton;
- * class QWidget;
- * class QMainWindow;
- * #endif
- */
-
-#include "global.h"
+#include "qtcommon.h"
 #include "contclasses.h"
+#include "settings.h"
+
+class MeterSlider;

 enum SpawnPos {
 	LEFT  = (1 << 1),
@ -61,7 +19,14 @@ enum CustomQEvent {
 	EndpointDefaultChange  = 1003,
 	SessionWidgetCreated   = 1004,
 	SessionWidgetObsolete  = 1005,
-	RecomposeMainWindow    = 1006	
+	RecomposeMainWindow    = 1006,
+	EndpointRoleChange     = 1007
+};
+
+class DarkModeEventFilter : public QAbstractNativeEventFilter {
+	
+public:
+    bool nativeEventFilter(const QByteArray &eventType, void *message, qintptr *) override;
 };

 template <typename T>
@ -73,32 +38,23 @@ public:
 };	
 //Q_DECLARE_METATYPE(EndpointWidgetEvent)

-class MeterSlider : public QSlider {
-	Q_OBJECT
-private:
-	float peakValue;
-protected:
-	bool event(QEvent* ev) override;
-	void paintEvent(QPaintEvent *event) override;
-	
-public:
-	void setPeakValue(float peakValue);
-	using QSlider::QSlider;
-};
-
 class ExtendedCheckBox : public QCheckBox {
 	Q_OBJECT
+private:
+	QIcon icons;
+	
 protected:
 	void customEvent(QEvent* ev) override;
+	void paintEvent(QPaintEvent* event) override;

 public:
 	//c++11: this inherits all parent's constructors unconditionally
 	using QCheckBox::QCheckBox;
+	void addIcon(char* const path, QIcon::State state);
 	//alternative being calling parent ctor directly after declaring child ctor:
 	//B(int x) : A(x) { }
 };

-
 class SessionWidget : public QWidget {
 Q_OBJECT

@ -117,7 +73,7 @@ private:
 	MeterSlider *mainSlider = nullptr;
 	uint64_t idx;
 	QHBoxLayout *widgetLayout = nullptr;
-	QCheckBox *muteButton = nullptr; 
+	ExtendedCheckBox *muteButton = nullptr; 
 	SessionHandler* sh;
 	QTimer* volumePoller = nullptr;
 	QSpacerItem* widthSpacer;
@ -150,7 +106,7 @@ public:
 	EndpointWidget(EndpointHandler* eph, QWidget *parent = nullptr, uint64_t idx = INT_MAX);
 	//QSize minimumSizeHint() const override;
 	//void setMinimum(uint64_t height, double heightRatio);
-	
+	void updateChannelsVisibility();
 	EndpointHandler* getEndpointHandler();
 	std::map<Roles, ExtendedCheckBox*> getDefaultRolesWidgets();
 	
@ -198,11 +154,9 @@ private:
 	size_t defaultRolesVectorSize = 4;
 	QTimer* timer = nullptr;
 	uint64_t idx;
-	ChannelWidget* cw;
+	ChannelWidget* cw = nullptr;
 	std::vector<SessionWidget*> sessionWidgets;
 	QSize minimum;
-	uint64_t currentWidth = 1;
-	uint64_t currentHeight = 1;
 	//std::vector<EndpointHandler*> *ephs;
 	//std::vector<QSlider> *sliders;
 	
@ -219,10 +173,11 @@ public:

 private:
 	QGridLayout *widgetLayout;
-	QPushButton *about;
+	//QPushButton *about;
 	#ifdef WIN32
 	QPushButton *openCP;
-	QPushButton *startup;
+	QCheckBox   *startup;
+	QCheckBox   *channels;
 	#endif
 };

@ -233,7 +188,8 @@ class MainWindow : public QMainWindow {
 public:
 	MainWindow(QWidget *parent = nullptr);
 	void reloadEndpointWidgets();
-	void compose();
+	void compose(bool isVisible);
+	void updateColor(uint8_t r, uint8_t g, uint8_t b, uint8_t a);

 protected:
 	void closeEvent(QCloseEvent *event) override;	
@ -252,8 +208,14 @@ private slots:

 private:
 	//std::vector<EndpointHandler*> *ephs;
+	bool eventFilter(QObject *object, QEvent *event) override;
+	void flushRoleChanges();
+	void changeFrontDefaults(Roles role, EndpointWidget* newDef, EndpointWidget* oldDef);
+	
 	std::vector<EndpointWidget*> ews;
-	QWidget *widget;
+	std::deque<std::pair<Roles, std::wstring>> roleBucketList;
+	std::mutex roleBucketMutex;
+	QWidget *containerWidget;
 	QGridLayout *widgetLayout;

 	QSystemTrayIcon *trayIcon;
@ -263,6 +225,7 @@ private:
 	QTimer *ewsUpdateTimer;
 	static constexpr uint64_t ewsUpdateTimerFrequency = 500;
 	double widthRatio = 0.28;
+	double dpr = 1.0;
 	bool recentlyClosed = false;
 	uint8_t recentlyClosedTimerFrequency = 1000;
 	QTimer *recentlyClosedTimer;
@ -272,7 +235,10 @@ private:
 	QToolBar *mainMenuBar;
 	QScreen *screen;
 	QSpacerItem* lastRowSpacer;
-	
+	QLabel* noEndpoints = nullptr;
+
+	QFont font;
+	friend class EndpointWidget;
 	//public slots:
 	//	void setEndpointHandlers(std::vector<EndpointHandler*> *ephs);
 	
@ -280,5 +246,3 @@ private:
    //void valueChanged(int value);

 };
-
-//#endif
--- a/src/qt/qtcommon.h
+++ b/src/qt/qtcommon.h
@ -0,0 +1,254 @@
+#pragma once
+#include <QLocalSocket>
+#include <QLocalServer>
+#include <QString>
+#include <QFile>
+#include <QStringList>
+#include <QStyleFactory>
+#include <QPalette>
+
+#include <QMainWindow>
+#include <QApplication>
+#include <QCloseEvent>
+
+#include <QIcon>
+#include <QSystemTrayIcon>
+#include <QMenu>
+//#include <QMessageBox>
+
+#include <QLabel>
+#include <QSlider>
+#include <QGridLayout>
+#include <QPushButton>
+#include <QCheckBox>
+#include <QTimer>
+#include <QScrollArea>
+#include <QScrollBar>
+#include <QSize>
+#include <QMenuBar>
+#include <QMenu>
+#include <QScreen>
+#include <QToolBar>
+#include <QWindow>
+#include <QPainter>
+#include <QStyle>
+#include <QStyleOptionComplex>
+#include <QStyleOptionSlider>
+#include <QStylePainter>
+#include <QStyleOptionSlider>
+#include <QFontMetrics>
+#include <QProxyStyle>
+#include <QPixmapCache>
+#include <QLatin1Char>
+#include <QLatin1String>
+#include <QFontDatabase>
+#include <QAbstractNativeEventFilter>
+#include <QAbstractEventDispatcher>
+#include <QSvgRenderer>
+//#include <QScrollbarStyleAnimation>
+//#include <QScrollBar>
+/*
+ * #else
+ * class QSlider;
+ * class QLabel;
+ * class QGridLayout;
+ * class QPushButton;
+ * class QWidget;
+ * class QMainWindow;
+ * #endif
+ */
+
+#include "global.h"
+
+enum CustomComplexControl {
+	CC_MeterSlider = 0xf0000001	
+};
+
+enum CustomControlElement {
+	CE_ExtendedCheckBox = 0xf0000001	
+};
+
+namespace StylingHelper {
+	
+	static inline void setBackgroundColor(bool lightMode) {
+		//QApplication* app = (QApplication*)QApplication::instance();
+		QPalette pal = QGuiApplication::palette();
+		if(lightMode) {
+			pal.setColor(QPalette::Window, Qt::white);
+			pal.setColor(QPalette::WindowText, Qt::black);
+		} else {
+			pal.setColor(QPalette::Window, Qt::black);
+			pal.setColor(QPalette::WindowText, Qt::white);
+		}
+		QGuiApplication::setPalette(pal);
+	}
+
+	static inline void setAccentColor(bool lightMode) {
+		//QApplication* app = (QApplication*)QApplication::instance();
+		QPalette pal = QGuiApplication::palette();
+		if(lightMode) {
+			pal.setColor(QPalette::Window, Qt::white);
+			pal.setColor(QPalette::WindowText, Qt::black);
+		} else {
+			pal.setColor(QPalette::Window, Qt::black);
+			pal.setColor(QPalette::WindowText, Qt::white);
+		}
+		QGuiApplication::setPalette(pal);
+	}
+
+	static inline bool argbToDiscreteValues(uint32_t color, uint8_t *r, uint8_t *g, uint8_t *b, uint8_t *a) {
+		if(!r || !g || !b || !a) return false;
+		
+		*a = (color >> 24) & 0xFF; 
+		*r = (color >> 16) & 0xFF; 
+		*g = (color >> 8) & 0xFF; 
+		*b = color & 0xFF;
+		return true;
+	} 
+	
+	static inline QLatin1String operator""_L1(const char* ch, uint64_t) {
+		return QLatin1String(ch);
+	}
+
+	static inline qreal calculateDpi(const QStyleOption *option) {
+	#ifndef Q_OS_DARWIN
+	    // Prioritize the application override, except for on macOS where
+	    // we have historically not supported the AA_Use96Dpi flag.
+	    if (QCoreApplication::testAttribute(Qt::AA_Use96Dpi))
+	        return 96;
+	#endif
+	
+	    // Expect that QStyleOption::QFontMetrics::QFont has the correct DPI set
+	    if (option)
+	        return option->fontMetrics.fontDpi();
+	
+	    // Fall back to historical Qt behavior: hardcoded 72 DPI on mac,
+	    // primary screen DPI on other platforms.
+	#ifdef Q_OS_DARWIN
+	    return qstyleBaseDpi;
+	#else
+	    return QGuiApplication::primaryScreen()->physicalDotsPerInch();
+	#endif
+	}
+
+	static inline qreal calculateDpi() {
+		return QFontMetrics(QApplication::font()).fontDpi();
+	}
+
+	/*
+	 * #ifdef Q_OS_DARWIN
+	 * static const qreal qstyleBaseDpi = 72;
+	 * #else
+	 * static const qreal qstyleBaseDpi = 96;
+	 * #endif
+	 */
+
+	//Q_GUI_EXPORT int qt_defaultDpiX() const;
+
+	
+	static inline qreal dpiScaled(qreal value, qreal dpi) {
+		static const qreal qstyleBaseDpi = 96;
+		return value * dpi / qstyleBaseDpi;
+	}
+
+	static inline qreal dpiScaled(qreal value, const QPaintDevice *device) {
+		return dpiScaled(value, device->logicalDpiX());
+	}
+
+	static inline qreal dpiScaled(qreal value, const QStyleOption *option) {
+		return dpiScaled(value, calculateDpi(option));
+	}
+
+	static inline bool isMacSystemPalette(const QPalette &pal) {
+        Q_UNUSED(pal);
+#if defined(Q_OS_MACOS)
+        const QPalette *themePalette = QGuiApplicationPrivate::platformTheme()->palette();
+        if (themePalette && themePalette->color(QPalette::Normal, QPalette::Highlight) ==
+                pal.color(QPalette::Normal, QPalette::Highlight) &&
+            themePalette->color(QPalette::Normal, QPalette::HighlightedText) ==
+                pal.color(QPalette::Normal, QPalette::HighlightedText))
+            return true;
+#endif
+        return false;
+    }
+
+	static inline QColor highlight(const QPalette &pal) {
+        if (isMacSystemPalette(pal))
+            return QColor(60, 140, 230);
+        return pal.color(QPalette::Highlight);
+    }
+
+	static inline QColor highlightedOutline(const QPalette &pal) {
+        QColor highlightedOutline = highlight(pal).darker(125);
+        if (highlightedOutline.value() > 160)
+            highlightedOutline.setHsl(highlightedOutline.hue(), highlightedOutline.saturation(), 160);
+        return highlightedOutline;
+    }
+
+	static inline QColor getOutline(const QPalette &pal) {
+        if (pal.window().style() == Qt::TexturePattern)
+            return QColor(0, 0, 0, 160);
+        return pal.window().color().darker(140);
+    }
+
+	static inline QColor getButtonColor(const QPalette &pal)  {
+        QColor buttonColor = pal.button().color();
+        int val = qGray(buttonColor.rgb());
+        buttonColor = buttonColor.lighter(100 + qMax(1, (180 - val)/6));
+        buttonColor.setHsv(buttonColor.hue(), buttonColor.saturation() * 0.75, buttonColor.value());
+        return buttonColor;
+    }
+
+	static inline QColor innerContrastLine()  {
+        return QColor(255, 255, 255, 30);
+    }
+
+	static inline QPixmap styleCachePixmap(const QSize &size, qreal pixelRatio) {
+		//not api
+		QPixmap cachePixmap = QPixmap(size * pixelRatio);
+		cachePixmap.setDevicePixelRatio(pixelRatio);
+		cachePixmap.fill(Qt::transparent);
+		return cachePixmap;
+	}
+
+	static inline QColor backgroundColor(const QPalette &pal, const QWidget* widget)
+	{
+		#if QT_CONFIG(scrollarea)
+		    if (qobject_cast<const QScrollBar *>(widget) && widget->parent() &&
+		            qobject_cast<const QAbstractScrollArea *>(widget->parent()->parent()))
+		        return widget->parentWidget()->parentWidget()->palette().color(QPalette::Base);
+		#else
+		    Q_UNUSED(widget);
+		#endif
+		    return pal.color(QPalette::Base);
+	}
+
+	static inline QPixmap svg2Pixmap(const QString& svgContent,
+									 const QSize& size,
+									 QPainter::CompositionMode mode = QPainter::CompositionMode_SourceOver)
+	{
+		QSvgRenderer rr(svgContent);
+		QImage image(size.width(), size.height(), QImage::Format_ARGB32);
+		QPainter painter(&image);
+		painter.setCompositionMode(mode);
+		image.fill(Qt::transparent);
+		rr.render(&painter);
+		return QPixmap::fromImage(image);
+	}
+
+	static inline QScreen* getCurrentScreen() {
+		//note: Using cursor pos as screen detector. Flawed. 
+		QPoint cursorPos = QCursor::pos();
+
+		for (QScreen *screen : QGuiApplication::screens()) {
+			QRect screenRect = screen->geometry();
+			if (screenRect.contains(cursorPos)) {
+				return screen;
+			}
+		}
+
+		return QGuiApplication::primaryScreen();
+	}
+
+}
+
--- a/src/qt/qtvisuals.h
+++ b/src/qt/qtvisuals.h
@ -0,0 +1,903 @@
+#pragma once
+
+#include "qtcommon.h"
+#include "meterslider.h"
+
+using namespace StylingHelper;
+
+class MixerStyle : public QProxyStyle {
+
+public:
+    using QProxyStyle::QProxyStyle;
+
+    //void drawComplexControl(ComplexControl cc, const QStyleOptionComplex *option,
+	//						QPainter *painter, const QWidget *widget) const override;
+	//Click on slider = move handle to click pos
+	int styleHint(QStyle::StyleHint hint, const QStyleOption* option = 0, const QWidget* widget = 0,
+				  QStyleHintReturn* returnData = 0) const {
+        if (hint == QStyle::SH_Slider_AbsoluteSetButtons)
+            return (Qt::LeftButton | Qt::MiddleButton | Qt::RightButton);
+        return baseStyle()->styleHint(hint, option, widget, returnData);
+    }
+
+	QRect subControlRect(ComplexControl control,
+						 const QStyleOptionComplex *option,
+						 SubControl subControl,
+						 const QWidget *widget) const        {
+		QRect rect = QCommonStyle::subControlRect(CC_Slider, option, subControl, widget);
+
+		switch (control) {
+#if QT_CONFIG(slider)
+		case CC_MeterSlider:
+			if (const QStyleOptionSlider *slider = qstyleoption_cast<const QStyleOptionSlider *>(option)) {
+				int tickSize = proxy()->pixelMetric(PM_SliderTickmarkOffset, option, widget);
+				switch (subControl) {
+				case SC_SliderHandle: {
+					const bool bothTicks = (slider->tickPosition & QSlider::TicksBothSides) == QSlider::TicksBothSides;
+					if (slider->orientation == Qt::Horizontal) {
+						rect.setHeight(baseStyle()->pixelMetric(PM_SliderThickness, option, widget));
+						rect.setWidth(baseStyle()->pixelMetric(PM_SliderLength, option, widget));
+						int centerY = slider->rect.center().y() - rect.height() / 2;
+						if (!bothTicks) {
+							if (slider->tickPosition & QSlider::TicksAbove)
+								centerY += tickSize;
+							if (slider->tickPosition & QSlider::TicksBelow)
+								centerY -= tickSize - 1;
+						}
+						rect.moveTop(centerY);
+					} else {
+						rect.setWidth(baseStyle()->pixelMetric(PM_SliderThickness, option, widget));
+						rect.setHeight(baseStyle()->pixelMetric(PM_SliderLength, option, widget));
+						int centerX = slider->rect.center().x() - rect.width() / 2;
+						if (!bothTicks) {
+							if (slider->tickPosition & QSlider::TicksAbove)
+								centerX += tickSize;
+							if (slider->tickPosition & QSlider::TicksBelow)
+								centerX -= tickSize - 1;
+						}
+						rect.moveLeft(centerX);
+					}
+				}
+					break;
+				case SC_SliderGroove: {
+					QPoint grooveCenter = slider->rect.center();
+					//rect.setWidth(std::abs(grooveCenter.x()) * 2);
+					const int grooveThickness = dpiScaled(7, option); //QStyleHelper::dpiScaled(7, option);
+					const bool bothTicks = (slider->tickPosition & QSlider::TicksBothSides) == QSlider::TicksBothSides;
+					if (slider->orientation == Qt::Horizontal) {
+						rect.setHeight(grooveThickness);
+						if (!bothTicks) {
+							if (slider->tickPosition & QSlider::TicksAbove)
+								grooveCenter.ry() += tickSize;
+							if (slider->tickPosition & QSlider::TicksBelow)
+								grooveCenter.ry() -= tickSize - 1;
+						}
+					} else {
+						rect.setWidth(grooveThickness);
+						if (!bothTicks) {
+							if (slider->tickPosition & QSlider::TicksAbove)
+								grooveCenter.rx() += tickSize;
+							if (slider->tickPosition & QSlider::TicksBelow)
+								grooveCenter.rx() -= tickSize - 1;
+						}
+					}
+					rect.moveCenter(grooveCenter);
+					break;
+				}
+				default:
+					break;
+				}
+			}
+			return rect;
+			break;
+#endif // QT_CONFIG(slider)
+#if QT_CONFIG(scrollbar)
+		case CC_ScrollBar:
+			if (const QStyleOptionSlider *scrollbar = qstyleoption_cast<const QStyleOptionSlider *>(option)) {
+				QRect scrollBarRect = scrollbar->rect;
+				const uint64_t offset = 7;
+				scrollBarRect.setWidth(scrollBarRect.width() / 2);
+				scrollBarRect.setHeight(scrollBarRect.height() - 15);
+				int maxlen = ((scrollbar->orientation == Qt::Horizontal) ?
+							  scrollBarRect.width() : scrollBarRect.height());
+				int sliderlen;
+
+				// calculate slider length
+				if (scrollbar->maximum != scrollbar->minimum) {
+					uint range = scrollbar->maximum - scrollbar->minimum;
+					sliderlen = (qint64(scrollbar->pageStep) * maxlen) / (range + scrollbar->pageStep);
+
+					int slidermin = baseStyle()->pixelMetric(PM_ScrollBarSliderMin, scrollbar, widget);
+					if (sliderlen < slidermin || range > INT_MAX / 2)
+						sliderlen = slidermin;
+					if (sliderlen > maxlen)
+						sliderlen = maxlen;
+				} else {
+					sliderlen = maxlen;
+				}
+
+				int sliderstart = sliderPositionFromValue(scrollbar->minimum,
+																	 scrollbar->maximum,
+																	 scrollbar->sliderPosition,
+																	 maxlen - sliderlen,
+																	 scrollbar->upsideDown);
+
+				switch (subControl) {
+				/*
+				 * case SC_ScrollBarSubLine:            // top/left button
+				 * 	if (scrollbar->orientation == Qt::Horizontal) {
+				 * 		int buttonWidth = qMin(scrollBarRect.width() / 2, sbextent);
+				 * 		rect.setRect(0, 0, buttonWidth, scrollBarRect.height());
+				 * 	} else {
+				 * 		int buttonHeight = qMin(scrollBarRect.height() / 2, sbextent);
+				 * 		rect.setRect(0, 0, scrollBarRect.width(), buttonHeight);
+				 * 	}
+				 * 	break;
+				 * case SC_ScrollBarAddLine:            // bottom/right button
+				 * 	if (scrollbar->orientation == Qt::Horizontal) {
+				 * 		int buttonWidth = qMin(scrollBarRect.width()/2, sbextent);
+				 * 		rect.setRect(scrollBarRect.width() - buttonWidth, 0, buttonWidth, scrollBarRect.height());
+				 * 	} else {
+				 * 		int buttonHeight = qMin(scrollBarRect.height()/2, sbextent);
+				 * 		rect.setRect(0, scrollBarRect.height() - buttonHeight, scrollBarRect.width(), buttonHeight);
+				 * 	}
+				 * 	break;
+				 */
+				case SC_ScrollBarSubPage:            // between top/left button and slider
+					if (scrollbar->orientation == Qt::Horizontal)
+						rect.setRect(0, 0, sliderstart, scrollBarRect.height());
+					else
+						rect.setRect(0, 0, scrollBarRect.width(), sliderstart);
+					break;
+				case SC_ScrollBarAddPage:            // between bottom/right button and slider
+					if (scrollbar->orientation == Qt::Horizontal)
+						rect.setRect(sliderstart + sliderlen, 0,
+									 maxlen - sliderstart - sliderlen, scrollBarRect.height());
+					else
+						rect.setRect(0, sliderstart + sliderlen, scrollBarRect.width(),
+									 maxlen - sliderstart - sliderlen);
+					break;
+				case SC_ScrollBarGroove:
+					if (scrollbar->orientation == Qt::Horizontal)
+						rect.setRect(offset, 0, scrollBarRect.width(),
+									 scrollBarRect.height());
+					else
+						rect.setRect(0, offset, scrollBarRect.width(),
+									 scrollBarRect.height() );
+					break;
+				case SC_ScrollBarSlider:
+					if (scrollbar->orientation == Qt::Horizontal)
+						rect.setRect(sliderstart + offset, 0, sliderlen, scrollBarRect.height());
+					else
+						rect.setRect(0, sliderstart + offset, scrollBarRect.width(), sliderlen);
+					break;
+				default:
+					break;
+				}
+				rect = visualRect(scrollbar->direction, scrollBarRect, rect);
+				return rect;
+			}
+			break;
+#endif // QT_CONFIG(scrollbar)
+		default:
+			return baseStyle()->subControlRect(control, option, subControl, widget);
+			break;
+		}
+
+		return QRect();
+
+	}
+
+	void drawControl(ControlElement element, const QStyleOption *opt,
+                               QPainter *p, const QWidget *widget) const
+	{
+		switch(element) {
+	    case CE_ExtendedCheckBox:
+			if (const QStyleOptionButton *btn = qstyleoption_cast<const QStyleOptionButton *>(opt)) {
+				QStyleOptionButton subopt = *btn;
+				subopt.rect = subElementRect(SE_CheckBoxIndicator, btn, widget);
+				//proxy()->drawPrimitive(PE_IndicatorCheckBox, &subopt, p, widget);
+				subopt.rect = subElementRect(SE_CheckBoxContents, btn, widget);
+				
+				//proxy()->drawControl(CE_CheckBoxLabel, &subopt, p, widget);
+				int alignment = visualAlignment(btn->direction, Qt::AlignLeft | Qt::AlignVCenter);
+
+				if (!proxy()->styleHint(SH_UnderlineShortcut, btn, widget))
+					alignment |= Qt::TextHideMnemonic;
+				QPixmap pix;
+				QRect textRect = btn->rect;
+				if (!btn->icon.isNull()) {
+					pix = btn->icon.pixmap(btn->iconSize, StylingHelper::getCurrentScreen()->devicePixelRatio(),
+										   QIcon::Mode::Normal, btn->state & State_On ? QIcon::On : QIcon::Off);
+					proxy()->drawItemPixmap(p, btn->rect, alignment, pix);
+					if (btn->direction == Qt::RightToLeft)
+						textRect.setRight(textRect.right() - btn->iconSize.width() - 4);
+					else
+						textRect.setLeft(textRect.left() + btn->iconSize.width() + 4);
+				}
+				if (!btn->text.isEmpty()){
+					proxy()->drawItemText(p, textRect, alignment | Qt::TextShowMnemonic,
+										  btn->palette, btn->state & State_Enabled, btn->text, QPalette::WindowText);
+				}
+				//
+				if (btn->state & State_HasFocus) {
+					QStyleOptionFocusRect fropt;
+					fropt.QStyleOption::operator=(*btn);
+					fropt.rect = subElementRect(SE_CheckBoxFocusRect, btn, widget);
+					proxy()->drawPrimitive(PE_FrameFocusRect, &fropt, p, widget);
+				}
+			}
+		default:
+			baseStyle()->drawControl(element, opt, p, widget);
+			break;
+		}
+	}
+
+	void drawComplexControl(ComplexControl cc, const QStyleOptionComplex *option,
+ 									QPainter *painter, const QWidget *widget) const {
+	QColor outline;
+	switch (cc) {
+	#if QT_CONFIG(slider)
+    case CC_MeterSlider:
+        if (const QStyleOptionSlider *slider = qstyleoption_cast<const QStyleOptionSlider *>(option)) {
+            const qreal dpr = painter->device()->devicePixelRatio();
+			const QColor buttonColor = getButtonColor(option->palette);
+            QRect groove = this->subControlRect(static_cast<QStyle::ComplexControl>(CC_MeterSlider), option, SC_SliderGroove, widget);
+            QRect handle = this->subControlRect(static_cast<QStyle::ComplexControl>(CC_MeterSlider), option, SC_SliderHandle, widget);
+
+            bool horizontal = slider->orientation == Qt::Horizontal;
+            bool ticksAbove = slider->tickPosition & QSlider::TicksAbove;
+            bool ticksBelow = slider->tickPosition & QSlider::TicksBelow;
+            QColor activeHighlight = highlight(option->palette);
+            QPixmap cache;
+            QBrush oldBrush = painter->brush();
+            QPen oldPen = painter->pen();
+            QColor shadowAlpha(Qt::black);
+            shadowAlpha.setAlpha(10);
+			
+            if (option->state & State_HasFocus && option->state & State_KeyboardFocusChange)
+                outline = highlightedOutline(option->palette);
+
+            if ((option->subControls & SC_SliderGroove) && groove.isValid()) {
+                QColor grooveColor;
+                grooveColor.setHsv(buttonColor.hue(),
+                                   qMin(255, (int)(buttonColor.saturation())),
+                                   qMin(255, (int)(buttonColor.value()*0.9)));
+                QString groovePixmapName = "slider_groove" + QString::number(groove.width());//QStyleHelper::uniqueName("slider_groove"_L1, option, groove.size(), dpr);
+                QRect pixmapRect(0, 0, groove.width(), groove.height());
+
+                // draw background groove
+                if (!QPixmapCache::find(groovePixmapName, &cache)) {
+                    cache = styleCachePixmap(pixmapRect.size(), dpr);
+                    QPainter groovePainter(&cache);
+                    groovePainter.setRenderHint(QPainter::Antialiasing, true);
+                    groovePainter.translate(0.5, 0.5);
+                    QLinearGradient gradient;
+                    if (horizontal) {
+                        gradient.setStart(pixmapRect.center().x(), pixmapRect.top());
+                        gradient.setFinalStop(pixmapRect.center().x(), pixmapRect.bottom());
+                    }
+                    else {
+                        gradient.setStart(pixmapRect.left(), pixmapRect.center().y());
+                        gradient.setFinalStop(pixmapRect.right(), pixmapRect.center().y());
+                    }
+                    groovePainter.setPen(QPen(outline));
+                    gradient.setColorAt(0, grooveColor.darker(110));
+                    gradient.setColorAt(1, grooveColor.lighter(110));//palette.button().color().darker(115));
+                    groovePainter.setBrush(gradient);
+                    groovePainter.drawRoundedRect(pixmapRect.adjusted(1, 1, -2, -2), 1, 1);
+                    groovePainter.end();
+                    QPixmapCache::insert(groovePixmapName, cache);
+                }
+                painter->drawPixmap(groove.topLeft(), cache);
+
+                // draw groove lines (vol + unattenuated vol)
+				const MeterSlider* widgetCast = qobject_cast<const MeterSlider*>(widget);
+				if (widgetCast) {
+					QRect clipRect;
+					//if (!groovePixmapName.isEmpty()) groovePixmapName += QLatin1String("_unattenuated");
+					//groovePixmapName += "_unattenuated"_L1;
+					//lf (!QPixmapCache::find(groovePixmapName, &cache)) {
+						cache = styleCachePixmap(pixmapRect.size(), dpr);
+						QPainter groovePainter(&cache);
+						QLinearGradient gradient;
+						if (horizontal) {
+							gradient.setStart(pixmapRect.center().x(), pixmapRect.top());
+							gradient.setFinalStop(pixmapRect.center().x(), pixmapRect.bottom());
+						}
+						else {
+							gradient.setStart(pixmapRect.left(), pixmapRect.center().y());
+							gradient.setFinalStop(pixmapRect.right(), pixmapRect.center().y());
+						}
+						QColor highlight = QColor(30,30,30,100); //this->highlight(option->palette);
+						QColor highlightedoutline = highlight.darker(140);
+						QColor grooveOutline = outline;
+						if (qGray(grooveOutline.rgb()) > qGray(highlightedoutline.rgb()))
+							grooveOutline = highlightedoutline;
+
+						float peakValue = ((MeterSlider*)widget)->peakValue;
+						groovePainter.setRenderHint(QPainter::Antialiasing, true);
+						groovePainter.translate(0.5, 0.5);
+						groovePainter.setPen(QPen(grooveOutline));
+						gradient.setColorAt(0, highlight);
+						gradient.setColorAt(1, highlight.lighter(130));
+						groovePainter.setBrush(gradient);
+						groovePainter.drawRoundedRect(pixmapRect.adjusted(
+														1, 1,
+														-pixmapRect.width() + (pixmapRect.width() * peakValue),
+														-2), 1, 1);
+						groovePainter.setPen(innerContrastLine());
+						groovePainter.setBrush(Qt::green);
+						double stepWidth = (double)widgetCast->width() * ((double)widgetCast->singleStep() / (widgetCast->maximum() - widgetCast->minimum()));
+						groovePainter.drawRoundedRect(pixmapRect.adjusted(
+														1, 1,
+														-pixmapRect.width() + ((widgetCast->width() - ((widgetCast->maximum() - widgetCast->value()) * stepWidth)) * peakValue),
+														-2), 1, 1);
+						
+						groovePainter.end();
+						//QPixmapCache::insert(groovePixmapName, cache);
+						//}
+					//}
+                if (horizontal) {
+                    if (slider->upsideDown)
+                        clipRect = QRect(handle.right(), groove.top(), groove.right() - handle.right(), groove.height());
+                    else
+                        clipRect = QRect(groove.left() + 2, groove.top() + 2,
+                                         groove.right() - 2, 2);
+                } else {
+                    if (slider->upsideDown)
+                        clipRect = QRect(groove.left(), handle.bottom(), groove.width(), groove.height() - (handle.bottom() - slider->rect.top()));
+                    else
+                        clipRect = QRect(groove.left(), groove.top(), groove.width(), handle.top() - groove.top());
+                }
+                painter->save();
+                painter->setClipRect(clipRect.adjusted(0, 0, 1, 1), Qt::IntersectClip);
+                painter->drawPixmap(groove.topLeft(), cache);
+                painter->restore();
+            }
+			}
+            if (option->subControls & SC_SliderTickmarks) {
+                painter->save();
+                painter->translate(slider->rect.x(), slider->rect.y());
+                painter->setPen(outline);
+                int tickSize = proxy()->pixelMetric(PM_SliderTickmarkOffset, option, widget);
+                int available = proxy()->pixelMetric(PM_SliderSpaceAvailable, slider, widget);
+                int interval = slider->tickInterval;
+                if (interval <= 0) {
+                    interval = slider->singleStep;
+                    if (QStyle::sliderPositionFromValue(slider->minimum, slider->maximum, interval,
+                                                        available)
+                            - QStyle::sliderPositionFromValue(slider->minimum, slider->maximum,
+                                                              0, available) < 3)
+                        interval = slider->pageStep;
+                }
+                if (interval <= 0)
+                    interval = 1;
+
+                int v = slider->minimum;
+                int len = proxy()->pixelMetric(PM_SliderLength, slider, widget);
+                QVector<QLine> lines;
+                while (v <= slider->maximum + 1) {
+                    if (v == slider->maximum + 1 && interval == 1)
+                        break;
+                    const int v_ = qMin(v, slider->maximum);
+                    int pos = sliderPositionFromValue(slider->minimum, slider->maximum,
+                                                      v_, (horizontal
+                                                           ? slider->rect.width()
+                                                           : slider->rect.height()) - len,
+                                                      slider->upsideDown) + len / 2;
+                    int extra = 2 - ((v_ == slider->minimum || v_ == slider->maximum) ? 1 : 0);
+
+                    if (horizontal) {
+                        if (ticksAbove) {
+                            lines += QLine(pos, slider->rect.top() + extra,
+                                           pos, slider->rect.top() + tickSize);
+                        }
+                        if (ticksBelow) {
+                            lines += QLine(pos, slider->rect.bottom() - extra,
+                                           pos, slider->rect.bottom() - tickSize);
+                        }
+                    } else {
+                        if (ticksAbove) {
+                            lines += QLine(slider->rect.left() + extra, pos,
+                                           slider->rect.left() + tickSize, pos);
+                        }
+                        if (ticksBelow) {
+                            lines += QLine(slider->rect.right() - extra, pos,
+                                           slider->rect.right() - tickSize, pos);
+                        }
+                    }
+                    // in the case where maximum is max int
+                    int nextInterval = v + interval;
+                    if (nextInterval < v)
+                        break;
+                    v = nextInterval;
+                }
+                painter->drawLines(lines);
+                painter->restore();
+            }
+            // draw handle
+            if ((option->subControls & SC_SliderHandle) ) {
+                QString handlePixmapName = "slider_handle" + QString::number(handle.height());//QStyleHelper::uniqueName("slider_handle"_L1, option,//handle.size(), dpr);
+                if (!QPixmapCache::find(handlePixmapName, &cache)) {
+                    cache = styleCachePixmap(handle.size(), dpr);
+                    QRect pixmapRect(0, 0, handle.width(), handle.height());
+                    QPainter handlePainter(&cache);
+                    QRect gradRect = pixmapRect.adjusted(2, 2, -2, -2);
+
+                    // gradient fill
+                    QRect r = pixmapRect.adjusted(1, 1, -2, -2);
+                    QLinearGradient gradient = qt_fusion_gradient(gradRect, getButtonColor(option->palette),horizontal ? TopDown : FromLeft);
+
+                    handlePainter.setRenderHint(QPainter::Antialiasing, true);
+                    handlePainter.translate(0.5, 0.5);
+
+                    handlePainter.setPen(Qt::NoPen);
+                    handlePainter.setBrush(QColor(0, 0, 0, 40));
+                    handlePainter.drawRect(horizontal ? r.adjusted(-1, 2, 1, -2) : r.adjusted(2, -1, -2, 1));
+
+                    handlePainter.setPen(QPen(getOutline(option->palette)));
+                    if (option->state & State_HasFocus && option->state & State_KeyboardFocusChange)
+                        handlePainter.setPen(QPen(highlightedOutline(option->palette)));
+
+                    handlePainter.setBrush(gradient);
+                    handlePainter.drawRoundedRect(r, 2, 2);
+                    handlePainter.setBrush(Qt::NoBrush);
+                    handlePainter.setPen(innerContrastLine());
+                    handlePainter.drawRoundedRect(r.adjusted(1, 1, -1, -1), 2, 2);
+
+                    QColor cornerAlpha = outline.darker(120);
+                    cornerAlpha.setAlpha(80);
+
+                    //handle shadow
+                    handlePainter.setPen(shadowAlpha);
+                    handlePainter.drawLine(QPoint(r.left() + 2, r.bottom() + 1), QPoint(r.right() - 2, r.bottom() + 1));
+                    handlePainter.drawLine(QPoint(r.right() + 1, r.bottom() - 3), QPoint(r.right() + 1, r.top() + 4));
+                    handlePainter.drawLine(QPoint(r.right() - 1, r.bottom()), QPoint(r.right() + 1, r.bottom() - 2));
+
+                    handlePainter.end();
+                    QPixmapCache::insert(handlePixmapName, cache);
+                }
+
+                painter->drawPixmap(handle.topLeft(), cache);
+
+            }
+            painter->setBrush(oldBrush);
+            painter->setPen(oldPen);
+        }
+        break;
+	case CC_ScrollBar:
+        painter->save();
+        if (const QStyleOptionSlider *scrollBar = qstyleoption_cast<const QStyleOptionSlider *>(option)) {
+            bool wasActive = false;
+            qreal expandScale = 1.0;
+            qreal expandOffset = -1.0;
+            QObject *styleObject = option->styleObject;
+			
+			QColor buttonColor = calculateButtonColor(option->palette);
+			QColor gradientStartColor = buttonColor.lighter(104);
+            QColor gradientStopColor = buttonColor.darker(102);
+			
+            bool transient = styleHint(SH_ScrollBar_Transient, option, widget);
+            bool horizontal = scrollBar->orientation == Qt::Horizontal;
+            bool sunken = scrollBar->state & State_Sunken;
+
+            QRect scrollBarSubLine = subControlRect(cc, scrollBar, SC_ScrollBarSubLine, widget);
+            QRect scrollBarAddLine = subControlRect(cc, scrollBar, SC_ScrollBarAddLine, widget);
+            QRect scrollBarSlider = subControlRect(cc, scrollBar, SC_ScrollBarSlider, widget);
+            QRect scrollBarGroove = subControlRect(cc, scrollBar, SC_ScrollBarGroove, widget);
+
+            QRect rect = option->rect;
+			outline = highlightedOutline(option->palette);
+            QColor alphaOutline = outline;
+            alphaOutline.setAlpha(180);
+
+            QColor arrowColor = option->palette.windowText().color();
+			//QColor arrowColor = QColor(188,143,143,100);
+            arrowColor.setAlpha(160);
+
+            const QColor appBgColor = QGuiApplication::palette().window().color();
+            const bool isDarkBg = appBgColor.red() < 128 && appBgColor.green() < 128 && appBgColor.blue() < 128;
+
+            if (transient) {
+                if (horizontal) {
+                    rect.setY(rect.y() + 4.5 - expandOffset);
+                    scrollBarSlider.setY(scrollBarSlider.y() + 4.5 - expandOffset);
+                    scrollBarGroove.setY(scrollBarGroove.y() + 4.5 - expandOffset);
+
+                    rect.setHeight(rect.height() * expandScale);
+                    scrollBarGroove.setHeight(scrollBarGroove.height() * expandScale);
+                } else {
+                    rect.setX(rect.x() + 4.5 - expandOffset);
+                    scrollBarSlider.setX(scrollBarSlider.x() + 4.5 - expandOffset);
+                    scrollBarGroove.setX(scrollBarGroove.x() + 4.5 - expandOffset);
+
+                    rect.setWidth(rect.width() * expandScale);
+                    scrollBarGroove.setWidth(scrollBarGroove.width() * expandScale);
+                }
+            }
+
+            // Paint groove
+            if ((!transient || scrollBar->activeSubControls || wasActive) && scrollBar->subControls & SC_ScrollBarGroove) {
+                QLinearGradient gradient(rect.center().x(), rect.top(),
+                                         rect.center().x(), rect.bottom());
+                if (!horizontal)
+                    gradient = QLinearGradient(rect.left(), rect.center().y(),
+                                               rect.right(), rect.center().y());
+                if (!transient || !isDarkBg) {
+                    gradient.setColorAt(0, buttonColor.darker(107));
+                    gradient.setColorAt(0.1, buttonColor.darker(105));
+                    gradient.setColorAt(0.9, buttonColor.darker(105));
+                    gradient.setColorAt(1, buttonColor.darker(107));
+                } else {
+                    gradient.setColorAt(0, appBgColor.lighter(157));
+                    gradient.setColorAt(0.1, appBgColor.lighter(155));
+                    gradient.setColorAt(0.9, appBgColor.lighter(155));
+                    gradient.setColorAt(1, appBgColor.lighter(157));
+                }
+				
+                painter->save();
+                //painter->fillRect(rect, gradient);
+                painter->setPen(Qt::NoPen);
+                painter->setPen(alphaOutline);
+				
+                QColor subtleEdge = alphaOutline;
+                subtleEdge.setAlpha(40);
+                painter->setPen(subtleEdge);
+                //painter->setBrush(Qt::NoBrush);
+				painter->setOpacity(0.3);
+				painter->setBrush(Qt::gray);
+				painter->drawRoundedRect(scrollBarGroove, 5, 5);
+                //painter->drawRoundedRect(scrollBarGroove, 5, 5);
+                painter->restore();
+            }
+
+            QRect pixmapRect = scrollBarSlider;
+			QColor highlightColor = option->palette.highlight().color();
+            /*
+			 * QLinearGradient gradient(pixmapRect.center().x(), pixmapRect.top(),
+             *                          pixmapRect.center().x(), pixmapRect.bottom());
+             * if (!horizontal)
+             *     gradient = QLinearGradient(pixmapRect.left(), pixmapRect.center().y(),
+             *                                pixmapRect.right(), pixmapRect.center().y());
+			 */
+
+            //QLinearGradient highlightedGradient = gradient;
+
+            QColor heldColor = 0xc4e3d7e0;//Qt::gray;//osh->isLightMode() ? Qt::white : Qt::black;
+            //gradient.setColorAt(0, option->palette.highlight().color());
+            //gradient.setColorAt(1, option->palette.highlight().color());
+			
+            //highlightedGradient.setColorAt(0, gradientStartColor.darker(102));
+            //highlightedGradient.setColorAt(1, gradientStopColor.lighter(102));
+
+            // Paint slider
+            if (scrollBar->subControls & SC_ScrollBarSlider) {
+				log_debugcpp("Final scrollbar paint if");
+                if (transient) {
+                    QRect rect = scrollBarSlider.adjusted(horizontal ? 1 : 2, horizontal ? 2 : 1, -1, -1);
+                    painter->setPen(Qt::NoPen);
+                    painter->setBrush(isDarkBg ? lightShade() : darkShade());
+                    int r = qMin(rect.width(), rect.height()) / 2;
+
+                    painter->save();
+                    painter->setRenderHint(QPainter::Antialiasing, true);
+                    painter->drawRoundedRect(rect, r, r);
+                    painter->restore();
+                } else {
+                    QRect pixmapRect = scrollBarSlider;
+                    painter->setPen(QPen(alphaOutline));
+                    if (option->state & State_Sunken
+						&& scrollBar->activeSubControls & SC_ScrollBarSlider)
+                        painter->setBrush(heldColor);
+                    else if (option->state & State_MouseOver
+							&& scrollBar->activeSubControls & SC_ScrollBarSlider) {
+						painter->setBrush(highlightColor);
+					}
+                    else //if (!isDarkBg)
+
+					if(!isDarkBg)
+							painter->setBrush(Qt::black);
+					else painter->setBrush(Qt::white);
+                    //else
+						// painter->setBrush(heldColor);
+
+                    painter->drawRoundedRect(pixmapRect.adjusted(horizontal ? -1 : 0, horizontal ? 0 : -1, horizontal ? 0 : -1, horizontal ? -1 : 0), 5, 5);
+
+                    painter->setPen(innerContrastLine());
+                    painter->drawRoundedRect(scrollBarSlider.adjusted(horizontal ? 0 : 1, horizontal ? 1 : 0, -1, -1), 5, 5);
+
+                    // Outer shadow
+                    //                  painter->setPen(subtleEdge);
+                    //                  if (horizontal) {
+                    ////                    painter->drawLine(scrollBarSlider.topLeft() + QPoint(-2, 0), scrollBarSlider.bottomLeft() + QPoint(2, 0));
+                    ////                    painter->drawLine(scrollBarSlider.topRight() + QPoint(-2, 0), scrollBarSlider.bottomRight() + QPoint(2, 0));
+                    //                  } else {
+                    ////                    painter->drawLine(pixmapRect.topLeft() + QPoint(0, -2), pixmapRect.bottomLeft() + QPoint(0, -2));
+                    ////                    painter->drawLine(pixmapRect.topRight() + QPoint(0, 2), pixmapRect.bottomRight() + QPoint(0, 2));
+                    //                  }
+                }
+            }
+
+            /*
+			 * // The SubLine (up/left) buttons
+             * if (!transient && scrollBar->subControls & SC_ScrollBarSubLine) {
+             *     if ((scrollBar->activeSubControls & SC_ScrollBarSubLine) && sunken)
+             *         painter->setBrush(gradientStopColor);
+             *     else if ((scrollBar->activeSubControls & SC_ScrollBarSubLine))
+             *         painter->setBrush(highlightedGradient);
+             *     else
+             *         painter->setBrush(gradient);
+			 * 
+             *     painter->setPen(Qt::NoPen);
+             *     painter->drawRoundedRect(scrollBarSubLine.adjusted(horizontal ? 0 : 1, horizontal ? 1 : 0, 0, 0), 1, 1);
+             *     painter->setPen(QPen(alphaOutline));
+             *     if (option->state & State_Horizontal) {
+             *         painter->drawRect(scrollBarSubLine.adjusted(horizontal ? 0 : 1, 0, horizontal ? 1 : 0, horizontal ? -1 : 0));
+             *     } else {
+             *         painter->drawRoundedRect(scrollBarSubLine.adjusted(0, 0, horizontal ? 0 : -1, 0), 1, 1);
+             *     }
+			 * 
+             *     QRect upRect = scrollBarSubLine.adjusted(horizontal ? 0 : 1, horizontal ? 1 : 0, horizontal ? -2 : -1, horizontal ? -1 : -2);
+             *     painter->setBrush(Qt::NoBrush);
+             *     painter->setPen(innerContrastLine());
+             *     painter->drawRect(upRect);
+			 * 
+             *     // Arrows
+             *     Qt::ArrowType arrowType = Qt::UpArrow;
+             *     if (option->state & State_Horizontal)
+             *         arrowType = option->direction == Qt::LeftToRight ? Qt::LeftArrow : Qt::RightArrow;
+             *     qt_fusion_draw_arrow(arrowType, painter, option, upRect, arrowColor);
+             * }
+			 * 
+             * // The AddLine (down/right) button
+             * if (!transient && scrollBar->subControls & SC_ScrollBarAddLine) {
+             *     if ((scrollBar->activeSubControls & SC_ScrollBarAddLine) && sunken)
+             *         painter->setBrush(gradientStopColor);
+             *     else if ((scrollBar->activeSubControls & SC_ScrollBarAddLine))
+             *         painter->setBrush(midColor2);
+             *     else
+             *         painter->setBrush(gradient);
+			 * 
+             *     painter->setPen(Qt::NoPen);
+             *     painter->drawRect(scrollBarAddLine.adjusted(horizontal ? 0 : 1, horizontal ? 1 : 0, 0, 0));
+             *     painter->setPen(QPen(alphaOutline, 1));
+             *     if (option->state & State_Horizontal) {
+             *         painter->drawRect(scrollBarAddLine.adjusted(horizontal ? -1 : 0, 0, horizontal ? -1 : 0, horizontal ? -1 : 0));
+             *     } else {
+             *         painter->drawRect(scrollBarAddLine.adjusted(0, horizontal ? 0 : -1, horizontal ? 0 : -1, horizontal ? 0 : -1));
+             *     }
+			 * 
+             *     QRect downRect = scrollBarAddLine.adjusted(1, 1, -1, -1);
+             *     painter->setPen(innerContrastLine());
+             *     painter->setBrush(Qt::NoBrush);
+             *     painter->drawRect(downRect);
+			 * 
+             *     Qt::ArrowType arrowType = Qt::DownArrow;
+             *     if (option->state & State_Horizontal)
+             *         arrowType = option->direction == Qt::LeftToRight ? Qt::RightArrow : Qt::LeftArrow;
+             *     qt_fusion_draw_arrow(arrowType, painter, option, downRect, arrowColor);
+             * }
+			 */
+
+        }
+        painter->restore();
+        break;
+	default:
+		baseStyle()->drawComplexControl(cc, option, painter, widget);
+#endif // QT_CONFIG(slider)
+}
+}
+
+private:
+	enum Direction {
+	    TopDown,
+	    FromLeft,
+	    BottomUp,
+	    FromRight
+	};
+	
+	static QLinearGradient qt_fusion_gradient(const QRect &rect, const QBrush &baseColor, Direction direction = TopDown)
+	{
+		int x = rect.center().x();
+		int y = rect.center().y();
+		QLinearGradient gradient;
+		switch (direction) {
+		case FromLeft:
+			gradient = QLinearGradient(rect.left(), y, rect.right(), y);
+			break;
+		case FromRight:
+			gradient = QLinearGradient(rect.right(), y, rect.left(), y);
+			break;
+		case BottomUp:
+			gradient = QLinearGradient(x, rect.bottom(), x, rect.top());
+			break;
+		case TopDown:
+		default:
+			gradient = QLinearGradient(x, rect.top(), x, rect.bottom());
+			break;
+		}
+		if (baseColor.gradient())
+			gradient.setStops(baseColor.gradient()->stops());
+		else {
+			QColor gradientStartColor = baseColor.color().lighter(124);
+			QColor gradientStopColor = baseColor.color().lighter(102);
+			gradient.setColorAt(0, gradientStartColor);
+			gradient.setColorAt(1, gradientStopColor);
+			//          Uncomment for adding shiny shading
+			//            QColor midColor1 = mergedColors(gradientStartColor, gradientStopColor, 55);
+			//            QColor midColor2 = mergedColors(gradientStartColor, gradientStopColor, 45);
+			//            gradient.setColorAt(0.5, midColor1);
+			//            gradient.setColorAt(0.501, midColor2);
+		}
+		return gradient;
+	}
+
+	 QColor highlightedOutline(const QPalette &pal) const {
+		 QColor highlightedOutline = highlight(pal);//.darker(25);//QColor(Qt::green);
+        if (highlightedOutline.value() > 160)
+            highlightedOutline.setHsl(highlightedOutline.hue(), highlightedOutline.saturation(), 160);
+        return highlightedOutline;
+    }
+
+	 QColor calculateButtonColor(const QPalette &pal) const {
+        QColor buttonColor = pal.button().color();
+        int val = qGray(buttonColor.rgb());
+        buttonColor = buttonColor.lighter(100 + qMax(1, (180 - val)/6));
+        buttonColor.setHsv(buttonColor.hue(), buttonColor.saturation() * 0.75, buttonColor.value());
+        return buttonColor;
+    }
+
+	// Used for grip handles
+    QColor lightShade() const {
+        return QColor(255, 255, 255, 90);
+    }
+	
+    QColor darkShade() const {
+        return QColor(0, 0, 0, 60);
+    }
+
+	QColor innerContrastLine() const {
+        return QColor(255, 255, 255, 30);
+    }
+
+	static QColor mergedColors(const QColor &colorA, const QColor &colorB, int factor = 50) {
+		const int maxFactor = 100;
+		QColor tmp = colorA;
+		tmp.setRed((tmp.red() * factor) / maxFactor + (colorB.red() * (maxFactor - factor)) / maxFactor);
+		tmp.setGreen((tmp.green() * factor) / maxFactor + (colorB.green() * (maxFactor - factor)) / maxFactor);
+		tmp.setBlue((tmp.blue() * factor) / maxFactor + (colorB.blue() * (maxFactor - factor)) / maxFactor);
+		return tmp;
+	}
+
+
+	static void qt_fusion_draw_arrow(Qt::ArrowType type, QPainter *painter, const QStyleOption *option, const QRect &rect, const QColor &color)
+{
+    if (rect.isEmpty())
+        return;
+
+    const qreal dpi = calculateDpi(option);
+    const qreal dpr = painter->device()->devicePixelRatio();
+    const int arrowWidth = int(dpiScaled(14, dpi));
+    const int arrowHeight = int(dpiScaled(8, dpi));
+
+    const int arrowMax = qMin(arrowHeight, arrowWidth);
+    const int rectMax = qMin(rect.height(), rect.width());
+    const int size = qMin(arrowMax, rectMax);
+
+    QPixmap cachePixmap;
+    const QString cacheKey = "fusion-arrow"_L1 + QString::number(rect.size().width()) + QString::number(rect.size().height()) + QString::number(type);
+		
+    if (!QPixmapCache::find(cacheKey, &cachePixmap)) {
+        cachePixmap = styleCachePixmap(rect.size(), dpr);
+        QPainter cachePainter(&cachePixmap);
+
+        QRectF arrowRect;
+        arrowRect.setWidth(size);
+        arrowRect.setHeight(arrowHeight * size / arrowWidth);
+        if (type == Qt::LeftArrow || type == Qt::RightArrow)
+            arrowRect = arrowRect.transposed();
+        arrowRect.moveTo((rect.width() - arrowRect.width()) / 2.0,
+                         (rect.height() - arrowRect.height()) / 2.0);
+
+        std::array<QPointF, 3> triangle;
+        switch (type) {
+        case Qt::DownArrow:
+            triangle = {arrowRect.topLeft(), arrowRect.topRight(), QPointF(arrowRect.center().x(), arrowRect.bottom())};
+            break;
+        case Qt::RightArrow:
+            triangle = {arrowRect.topLeft(), arrowRect.bottomLeft(), QPointF(arrowRect.right(), arrowRect.center().y())};
+            break;
+        case Qt::LeftArrow:
+            triangle = {arrowRect.topRight(), arrowRect.bottomRight(), QPointF(arrowRect.left(), arrowRect.center().y())};
+            break;
+        default:
+            triangle = {arrowRect.bottomLeft(), arrowRect.bottomRight(), QPointF(arrowRect.center().x(), arrowRect.top())};
+            break;
+        }
+
+        cachePainter.setPen(Qt::NoPen);
+        cachePainter.setBrush(color);
+        cachePainter.setRenderHint(QPainter::Antialiasing);
+        cachePainter.drawPolygon(triangle.data(), int(triangle.size()));
+
+        QPixmapCache::insert(cacheKey, cachePixmap);
+    }
+
+    painter->drawPixmap(rect, cachePixmap);
+}
+	
+};
+
+
+
+/*
+ * void MixerStyle::drawComplexControl(ComplexControl cc, const QStyleOptionComplex *opt,
+ *  									QPainter *p, const QWidget *widget) const {
+ * 	switch (cc) {
+ * 	#if QT_CONFIG(slider)
+ * 	case CC_Slider:
+ * 		if (const QStyleOptionSlider *slider = qstyleoption_cast<const QStyleOptionSlider *>(opt)) {
+ * 			if (slider->subControls == SC_SliderTickmarks) {
+ * 				int tickOffset = proxy()->pixelMetric(PM_SliderTickmarkOffset, slider, widget);
+ * 				int ticks = slider->tickPosition;
+ * 				int thickness = proxy()->pixelMetric(PM_SliderControlThickness, slider, widget);
+ * 				int len = proxy()->pixelMetric(PM_SliderLength, slider, widget);
+ * 				int available = proxy()->pixelMetric(PM_SliderSpaceAvailable, slider, widget);
+ * 				int interval = slider->tickInterval;
+ * 				if (interval <= 0) {
+ * 					interval = slider->singleStep;
+ * 					if (QStyle::sliderPositionFromValue(slider->minimum, slider->maximum, interval,
+ * 														available)
+ * 						- QStyle::sliderPositionFromValue(slider->minimum, slider->maximum,
+ * 														  0, available) < 3)
+ * 						interval = slider->pageStep;
+ * 				}
+ * 				if (!interval)
+ * 					interval = 1;
+ * 				int fudge = len / 2;
+ * 				int pos;
+ * 				// Since there is no subrect for tickmarks do a translation here.
+ * 			    p->save();
+ * 				p->translate(slider->rect.x(), slider->rect.y());
+ * 				p->setPen(slider->palette.windowText().color());
+ * 				int v = slider->minimum;
+ * 				while (v <= slider->maximum + 1) {
+ * 					if (v == slider->maximum + 1 && interval == 1)
+ * 						break;
+ * 					const int v_ = qMin(v, slider->maximum);
+ * 					pos = QStyle::sliderPositionFromValue(slider->minimum, slider->maximum,
+ * 														  v_, available) + fudge;
+ * 						if (slider->orientation == Qt::Horizontal) {
+ * 							if (ticks & QSlider::TicksAbove)
+ * 								p->drawLine(pos, 0, pos, tickOffset - 2);
+ * 							if (ticks & QSlider::TicksBelow)
+ * 								p->drawLine(pos, tickOffset + thickness + 1, pos,
+ * 											slider->rect.height()-1);
+ * 						} else {
+ * 						if (ticks & QSlider::TicksAbove)
+ * 							p->drawLine(0, pos, tickOffset - 2, pos);
+ * 						if (ticks & QSlider::TicksBelow)
+ * 							p->drawLine(tickOffset + thickness + 1, pos,
+ * 										slider->rect.width()-1, pos);
+ * 					}
+ * 					// in the case where maximum is max int
+ * 					int nextInterval = v + interval;
+ * 					if (nextInterval < v)
+ * 						break;
+ * 					v = nextInterval;
+ * 				}
+ * 			}
+ * 		}
+ * 		p->restore();
+ * 		break;
+ * 		default:
+ * 			baseStyle()->drawComplexControl(cc, opt, p, widget);	
+ * 			break;
+ * 	}
+ * 	#endif // QT_CONFIG(slider)
+ * }
+ */
+
+//void MixerStyle::
+
--- a/src/qtestmain.cpp
+++ b/src/qtestmain.cpp
@ -1,25 +1,22 @@
-#include <QApplication>
-#include <QMainWindow>
-
-#include <QLocalSocket>
-#include <QLocalServer>
-#include <QString>
-#include <QFile>
-#include <QStringList>
-#include <QStyleFactory>
 //#include "contclasses.h"
 #define INIT_FILELOG
+#include "qtcommon.h"
 #include "qtclasses.h"
-#include "global.h"
+#include "qtvisuals.h"
+#include "settings.h"

-OverseerHandler *osh = nullptr; 
-	
-QApplication* createApplication(int &argc, char *argv[])
-{
+OverseerHandler *osh = nullptr;
+ini::UserSettings *set = nullptr;
+
+bool startupRun = false;
+bool onStartup = false;
+char* userSettingsPath = nullptr;
+
+QApplication* createApplication(int &argc, char *argv[]) {
    return new QApplication(argc, argv);
 }

-bool isSingleInstanceRunning(QString appName) {
+bool isInstanceRunning(QString appName) {
    QLocalSocket socket;
    socket.connectToServer(appName);
    bool isOpen = socket.isOpen();
@ -27,7 +24,7 @@ bool isSingleInstanceRunning(QString appName) {
    return isOpen;
 }

-QLocalServer* startSingleInstanceServer(QString appName) {
+QLocalServer* startInstanceServer(QString appName) {
    QLocalServer* server = new QLocalServer;
    server->setSocketOptions(QLocalServer::WorldAccessOption);
    server->listen(appName);
@ -38,6 +35,36 @@ void closeDebugFileLog() {
 	close_file_log_buffer();
 }

+void parseCmdArgs(int argc, char* argv[]) {
+	if(argc == 1) return;
+	//char* configPath = nullptr;
+	char* arg[] = { (char*)"--config-path=", (char*)"--change-startup" };
+
+	for (int i = 1; i < argc; i++) {
+		if(strstr(argv[i], arg[0])) {
+			userSettingsPath = argv[i] + strlen(arg[0]);
+		}
+
+		if(strstr(argv[i], arg[1])) {
+			if (++i >= argc) return;
+			switch (argv[i][0]) {
+			case '0':
+				startupRun = true;
+				onStartup = false;
+				break;
+			case '1':
+				startupRun = true;
+				onStartup = true;
+				break;
+			default:
+				break;
+			}
+			return;
+		}
+	}
+	return;
+}
+
 /* set_terminate
 * void closeDebugFileLog2() {
 * 	close_file_log_buffer();
@ -47,35 +74,66 @@ void closeDebugFileLog() {

 int main (int argc, char* argv[]) {
 	/*
-	 * QStringList styles = QStyleFactory::keys();
-	 * for(QString a : styles) {
-	 * 	log_debugcpp(a.toStdString());
-	 * }
+	 * Debug: logging report file
 	 */
-	//QApplication::setStyle("Fusion");
-	//Check if running
-	//https://stackoverflow.com/questions/48060989/qt-show-application-if-currently-running
 	initialize_file_log();
 	atexit(closeDebugFileLog);
-	//std::set_terminate(closeDebugFileLog2);
-	if (!isSingleInstanceRunning("Mixer"))
-		startSingleInstanceServer("Mixer");
+
+	QApplication::setStyle(new MixerStyle(QStyleFactory::create("Fusion")));
+	//QApplication::setFont(font);
+	//QPalette palette = QGuiApplication::palette();
+
+	//palette.setColor(QPalette::Active, QPalette::Highlight, QColor(255, 192, 203, 200));
+	//QColor(30,30,30,100));
+	//QGuiApplication::setPalette(palette);
+	osh = new OverseerHandler();
+	osh->populateSystemValues();
+
+	/*
+	 * Arg parsing: (admin?) startup change run 
+	 */
+	parseCmdArgs(argc, argv);
+	if (startupRun) {
+		if (!isInstanceRunning(PIPE_NAME)) exit(-1);
+		//if (startupChangeInfo->permissionChangeScope == NONE) exit(-1);
+		osh->updateStartupConfig(onStartup);
+		exit(0);
+	}
+
+	//Check if running
+	//https://stackoverflow.com/questions/48060989/qt-show-application-if-currently-running
+	if (!isInstanceRunning(PIPE_NAME))
+		startInstanceServer(PIPE_NAME);
 	else exit(0);

-	osh = new OverseerHandler();
+	/*
+	 * Config file init
+	 */
+	if (userSettingsPath)
+		set = ini::UserSettings::createSettings(userSettingsPath, true);
+
+	if (set)
+		OverseerHandler::settingsPath = std::string(userSettingsPath);
+	else setConfigDirToDefaults();
+
+	StylingHelper::setBackgroundColor(osh->isLightMode());
 	//qRegisterMetaType<EndpointWidgetEvent>();
 	
 	//INIT CONT
 	log_debugcpp("main init");
-	osh->reloadEndpointHandlers();
+	osh->createEndpointHandlers();
 	log_debugcpp("Reloaded endpoint handlers");
 	
 	//INIT FRONT
 	QScopedPointer<QApplication> app(createApplication(argc, argv));
-
+	
 	MainWindow window = MainWindow();
 	//window.setSizePolicy(QSizePolicy::Fixed, QSizePolicy::QSizePolicy::MinimumExpanding)
 	QApplication::setQuitOnLastWindowClosed(false);
+
+	DarkModeEventFilter* darkMode = new DarkModeEventFilter();
+	QAbstractEventDispatcher::instance()->installNativeEventFilter(darkMode);
+	
 	/*
 	 * QFile styleFile(":/assets/style.qss");
 	 * styleFile.open(QFile::ReadOnly);
--- a/src/settings.cpp
+++ b/src/settings.cpp
@ -0,0 +1,231 @@
+#include "settings.h"
+#include "msinclude.h"
+
+namespace ini {
+
+	wchar_t* Utf8toUtf16(const char* str, uint64_t* size = nullptr) {
+		if(!str || str[0] == '\0') return nullptr;
+		int sizeNeeded = MultiByteToWideChar(CP_UTF8, 0, str, -1, NULL, 0);
+		if(size) *size = sizeNeeded;
+		wchar_t* utf16 = (wchar_t*)calloc(sizeNeeded, sizeof(wchar_t));
+		MultiByteToWideChar(CP_UTF8, 0, str, -1, utf16, sizeNeeded);
+		return utf16;
+	}
+	
+
+	
+	UserSettings::UserSettings(char* textContents) {
+		//Parsing values
+		bool isCRLF     = false;
+		char *curLine   = textContents;
+		char *separator = nullptr, *key = nullptr, *value = nullptr;
+		while(curLine) {
+			char* nextLine = strchr(curLine, '\n');
+			if(nextLine == curLine + 1 || nextLine == curLine + 2)
+				goto nextIteration;
+			if (nextLine && (isCRLF || *(nextLine - 1) == '\r')) {
+				isCRLF = true;
+				*(nextLine - 1) = '\0';
+			} else if (nextLine) *nextLine = '\0';  // temporarily terminate the current line
+			log_debugcpp("[SET] curLine: " + std::string(curLine) + " ");
+
+			separator = strchr(curLine, '=');
+			if(!separator)
+				goto nextIteration;
+			*separator = '\0';
+			key   = trimAndAllocate(curLine); 
+			value = trimAndAllocate(separator + 1);
+			values.try_emplace(key, value);
+			log_debugcpp("[SET] ini Map size: " + std::to_string(values.size()));
+			*separator = '=';
+
+		nextIteration:
+			if (nextLine) { // then restore newline-char, just to be tidy
+				if (isCRLF)
+					*(nextLine - 1) = '\r';
+				else *nextLine = '\n';
+			}
+			curLine = nextLine ? (nextLine + 1) : NULL;
+		}
+		free(textContents);
+	}
+	
+	char* const UserSettings::getValue(char* key, uint64_t len) {
+		if (auto search = values.find(key); search != values.end())
+			return (char* const) search->second;
+		return nullptr;
+	}
+
+	void UserSettings::setValue(char* key, char* value, uint64_t valueSize, uint64_t keySize) {
+		char *newValue, *newKey;
+		if (auto search = values.find(key); search != values.end()) {
+			if(!(strcmp(value, search->second))) return;
+			newValue = (char*)calloc(valueSize, sizeof(char));
+			if (!(search->second == pos || search->second == neg)) {
+				free(search->second);
+			}
+			search->second = newValue;
+			return;
+		}
+		
+		newValue = (char*)calloc(valueSize, sizeof(char));
+		newKey   = (char*)calloc(keySize, sizeof(char));
+		values.insert(std::make_pair(newKey, newValue));
+		return;
+	}
+
+	void UserSettings::setValue(char* key, bool value, uint64_t keySize) {
+		char *newKey;
+		log_debugcpp("[SET] Pos value: " + std::to_string((intptr_t)pos));
+		log_debugcpp("[SET] Neg value: " + std::to_string((intptr_t)neg));
+		if (auto search = values.find(key); search != values.end()) {
+			log_debugcpp("[SET] Previous value: " + std::to_string((intptr_t)values[key]));
+			if (!(search->second == pos || search->second == neg)) {
+				free(search->second);
+			}
+			if (value)
+				search->second = pos;
+			else search->second = neg;
+			return;
+		}
+		
+		newKey = (char*)calloc(keySize, sizeof(char));
+		memcpy(newKey, key, keySize * sizeof(char));
+		values.insert(std::make_pair(newKey, value ? pos : neg));
+		return;
+	}
+
+	bool UserSettings::save(const char* path) {
+		if(!path) return false;
+		uint64_t convertedPathSize = 0;
+		wchar_t* utf16Path = Utf8toUtf16(path, &convertedPathSize);
+		if(!utf16Path) return false;
+		
+		#define releaseBeforeReturn() do {		\
+			CloseHandle(settingsHandle); \
+			settingsHandle = nullptr; \
+			free(utf16Path); \
+			free(text); \
+		} while(0) 
+		
+		//We initially reserve 1024B for flushing. If storage is exceeded, more same-size chunks are allocated
+		const uint64_t chunkSize = 1024;
+		char* text = (char*)calloc(chunkSize, sizeof(char));
+		uint64_t mapSize = values.size();
+		uint64_t chunks = 1;
+		uint64_t keySize = 0, valueSize = 0, totalSize = 0, previousStepSize = 0;
+		//for(std::pair<char*, char*> entry : values) {
+		std::unordered_map<char*, char*, Djb12Hasher, StrcmpEqual>::iterator it;
+		for (it = values.begin(); it != values.end(); it++) {
+			keySize   =  strlen(it->first);
+			valueSize =  strlen(it->second);
+			totalSize += valueSize + keySize + (it == values.begin() ? 1 : 2); //newline and separator
+
+			if(totalSize > (chunkSize * chunks)) {
+				text = (char*)realloc(text, (++chunks * chunkSize));
+			}
+
+			if(it != values.begin())
+				memcpy(text + previousStepSize++, "\n", sizeof(char));
+			memcpy(text + previousStepSize, it->first, sizeof(char) * keySize);
+			memcpy(text + previousStepSize + keySize, "=", sizeof(char));
+			memcpy(text + previousStepSize + 1 + keySize, it->second, sizeof(char) * valueSize);
+			
+			previousStepSize = totalSize;
+		}
+
+		HANDLE settingsHandle = nullptr;
+		settingsHandle = CreateFile2(
+									 utf16Path,
+									 GENERIC_READ | GENERIC_WRITE,
+									 0,
+									 CREATE_ALWAYS,
+									 NULL);
+		if(settingsHandle == INVALID_HANDLE_VALUE) {
+			log_debugcpp("[SET] Can't save to file: " + std::to_string(GetLastError()));
+			releaseBeforeReturn();
+			return false;
+		}
+
+		DWORD bytesWritten;
+		BOOL writeSuccess = WriteFile(
+									  settingsHandle,
+									  text,
+									  totalSize,
+									  &bytesWritten,
+									  nullptr
+									   );
+
+		releaseBeforeReturn();
+		if (writeSuccess == TRUE) return true;
+		else return false;
+
+		return false;
+		#undef releaseBeforeReturn
+	}
+
+	UserSettings::~UserSettings() {
+		//if(textContents) free(textContents);
+		for(std::pair<char*, char*> entry : values) {
+			free(entry.first);
+			if (!(entry.second == pos || entry.second == neg)) 
+				free(entry.second);
+		}
+	}		
+
+	UserSettings* UserSettings::createSettings(const char* path, bool create) {
+		if(!path) return nullptr;
+		wchar_t* utf16Path = Utf8toUtf16(path);
+		if(!utf16Path) return nullptr;
+		
+		#define releaseBeforeReturn() do {		\
+			CloseHandle(settingsHandle); \
+			settingsHandle = nullptr; \
+			free(utf16Path); \
+		} while(0) 
+
+		char* textContents;
+		HANDLE settingsHandle = nullptr;
+		settingsHandle = CreateFile2(
+									 utf16Path,
+									 GENERIC_READ | GENERIC_WRITE,
+									 0,
+									 (create ? OPEN_ALWAYS : OPEN_EXISTING),
+									 NULL);
+		if(settingsHandle == INVALID_HANDLE_VALUE) {
+			std::string createString = std::string(create ? (char*)"create" : (char*)"open");
+			log_debugcpp("[SET] Can't create settings file: " + std::to_string(GetLastError()));
+			log_debugcpp("[SET] Can't " + createString + \
+						 " settings file on: " + std::string(path)  + \
+						 ", error: " + std::to_string(GetLastError()));
+			releaseBeforeReturn();
+			return nullptr;
+		}
+		
+		//Calculating file size and reading file
+		uint64_t fileSize;
+		LARGE_INTEGER fileSizeStruct;
+		if(!GetFileSizeEx(settingsHandle, &fileSizeStruct)) {
+			releaseBeforeReturn();
+			return nullptr;
+		}
+		fileSize = fileSizeStruct.QuadPart;
+
+		uint32_t bytesRead = 0;
+		uint64_t textContentsSize = fileSize + 1;
+		textContents = (char*)calloc(textContentsSize, sizeof(char));
+		if (ReadFile(settingsHandle, textContents, fileSize,
+					 (LPDWORD)&bytesRead, NULL)                         != TRUE) {
+			releaseBeforeReturn();
+			return nullptr;
+		}
+
+		releaseBeforeReturn();
+		return new UserSettings(textContents);
+		
+		//textContents.assign(tempTextContents);
+		//free(tempTextContents);
+		#undef releaseBeforeReturn
+	}
+
+}
--- a/src/settings.h
+++ b/src/settings.h
@ -0,0 +1,71 @@
+#pragma once 
+#include "global.h"
+
+namespace ini {
+	
+	//Trims spaces, LF and CRLF
+	static inline char* trimAndAllocate(const char* in, uint64_t len = 0) {
+        if (!in) return nullptr;
+
+        uint64_t startingPos = 0, lastPos = 0;
+        bool foundStart = false;
+        for(int i = 0; ;i++) {
+			char c = in[i];
+            if ((len > 0 && startingPos == (len - 1)) || (len > 0 && lastPos == (len - 1))) return nullptr;
+            if ((c != ' ' || c != '\r' || c != '\n') && !foundStart) {
+				foundStart = true;
+				lastPos = startingPos;
+			}
+			if (foundStart && (c == ' ' || c == '\r' || c == '\n')) {
+				break;
+			}
+            if(!foundStart)
+                startingPos++;
+            else lastPos++;
+        }
+		if(!(lastPos - startingPos)) return nullptr;
+		
+        char* trimmedString = (char*)calloc(lastPos - startingPos + 1, sizeof(char));
+        memcpy(trimmedString, in + startingPos, lastPos - startingPos);
+        return trimmedString;
+    }
+
+	struct Djb12Hasher {
+		size_t operator()(char* str) const {
+			unsigned long hash = 5381;
+			int c;
+
+			while (c = *str++)
+				hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
+
+			return hash;
+		}
+	};
+
+	struct StrcmpEqual {
+		bool operator()(char* key1, char* key2) const {
+			return (!strcmp(key1, key2));
+		}
+	};
+
+class UserSettings {
+
+ public:
+	static UserSettings* createSettings(const char* path = nullptr, bool create = false);
+	~UserSettings();
+	
+	char* const getValue(char* key, uint64_t len = 0);
+	void setValue(char* key, char* value, uint64_t valueSize, uint64_t keySize); //'\0' included
+	void setValue(char* key, bool  value, uint64_t keySize); //'\0' included
+
+	bool save(const char* path);
+ protected:
+
+ private:
+	UserSettings(char* text = nullptr);	
+	std::unordered_map<char*, char*, Djb12Hasher, StrcmpEqual> values;
+	char* pos = "true";
+	char* neg = "false";
+};
+
+}
Author	SHA1	Message	Date
Hane	8f864f3394	wip: icons	2026-01-31 18:09:02 +01:00
Hane	3239e60471	fixed synch issues + memleak @ name fetching	2025-01-25 17:27:36 +01:00
Hane	f1b734bea6	fixed visuals when adding epw/sw while window is visible	2025-01-18 18:51:32 +01:00
Hane	53f9506115	fixed newly arisen race cons (busywaits)	2025-01-18 18:01:35 +01:00
Hane	109330dbbd	fixed lots of edge cases revolving role changes	2025-01-16 22:13:41 +01:00
Hane	0a301fb9bf	fixed new endpoints not appering if UI open + no roles / deque	2025-01-16 20:29:02 +01:00
Hane	a3d00be3fe	fixed callback not released + unneded env func param	2025-01-16 18:09:02 +01:00
Hane	c60b6f71ed	updated build script & small installer name fix	2025-01-15 22:09:45 +01:00
Hane	f0d263d96e	changed misleading log message	2025-01-15 21:49:41 +01:00
Hane	59a92fa34b	fixed race cons ep/eph coll, unwanted session state update crash + some minor code cleanup	2025-01-15 21:47:35 +01:00
Hane	667482cfea	marshalling on sessions, missing override tag	2025-01-14 19:19:49 +01:00
Hane	cdde1ce9b8	installer done, recipe cleanup	2025-01-13 17:42:10 +01:00
Hane	c87c8d0990	set: fix wrong save path / fixed null deref / more env refactor	2025-01-07 18:53:17 +01:00
Hane	047808c89f	ref Env namespace for win32/reg stuff / startup toggle Bigger than usual commit, but all of this had to be done simultaneously	2025-01-07 00:00:50 +01:00
Hane	94d2ebf1c2	wip: working installer. cleanup/bindir/logo missing	2024-12-24 00:29:23 +01:00
Hane	801adbb17e	fixed 1px gaps/removed unnecesary com call	2024-12-18 00:44:33 +01:00
Hane	5e5365274c	changed session module name retrieval + name when wnd not shown	2024-12-17 23:00:44 +01:00
Hane	2a1b30e166	fix: sessionmanager life expired under my feet	2024-12-17 00:01:02 +01:00
Hane	9f7e7e30e2	ini: fixed insufficient utf8->16 alloc	2024-12-12 20:44:27 +01:00
Hane	adca5111f6	finished basic ini skeleton	2024-12-06 19:59:09 +01:00
Hane	1ae324b68a	wip: settings in effect	2024-12-06 17:55:46 +01:00
Hane	8e07b1efdd	wip: ini parse baseline	2024-12-03 21:13:42 +01:00
Hane	8e93120555	correct size on all resolutions	2024-11-27 20:46:02 +01:00
Hane	60890cecad	dark/light mode & accent color	2024-11-26 17:11:01 +01:00
Hane	13855c2e6f	wip: dark/light mode adaptation	2024-11-20 19:21:37 +01:00
Hane	0bf8b321ae	wip: endpoint add/remove/role change bugfixes	2024-08-15 18:07:13 +02:00
Hane	d4db24ed7d	wip: no endpoint, role rework, visual ratio	2024-08-14 17:02:57 +02:00
Hane	e42dbaa194	session shown name parsing, pending refactor	2024-08-08 15:04:17 +02:00
Hane	517f117575	o0 & windownames	2024-08-06 14:49:52 +02:00
Hane	42b30b1bf8	Og & wip: names	2024-08-06 09:45:25 +02:00
Hane	544da49e32	test: fixed unnamed sessions #6	2024-06-06 20:11:12 +02:00
Hane	313a26c8e3	wip: customize scroll bar	2024-06-01 22:28:24 +02:00
Hane	f7de5ef803	Qt code refactor w/ functional style	2024-05-30 19:23:09 +02:00
Hane	f8171f12f3	wip: bad build config, unnecesary reimpl. Step by step	2024-05-30 18:48:04 +02:00
Hane	0e123f886d	sliders value set to where clicked	2024-05-16 20:40:19 +02:00
Hane	b6b7e1c577	code cleanup: refactored ugly window width/scrheight cache	2024-05-14 19:48:11 +02:00
Hane	5d179bb91c	changed qmake recipe (static c++/unwind link)	2024-05-14 01:55:29 +02:00
Hane	c1665b33e2	removed SVV.exe	2024-05-13 16:27:35 +02:00