wip: icons

+ some minor code cleanup

.gitignore

@@ -1,6 +1,8 @@
 build
 *.rdbg
 *.pdb
+*.ps1
+*.exe
 Makefile
 Makefile.Debug
 Makefile.Release

README.md

@@ -0,0 +1,15 @@
+# Mixer
+
+## Build
+
+* Toolchain: [llvm-mingw UCRT 20220906](https://github.com/mstorsjo/llvm-mingw/releases/tag/20220906).
+
+* Clone [this](https://code.qt.io/cgit/qt/qt5.git/tag/?h=v6.3.2) Qt branch
+
+* Build Qt from sources following [this](https://wiki.qt.io/Building_Qt_6_from_Git) guide and executing `configure.bat` as such:
+
+```
+..\qt6\configure.bat -prefix ..\install -static -debug -opensource -confirm-license -qt-zlib -qt-libpng -qt-webp -qt-libjpeg -qt-freetype -skip qt3d -skip qtactiveqt -skip qtandroidextras -skip qtcharts -skip qtconnectivity -skip qtdatavis3d -skip qtdoc -skip qtgamepad -skip qtlocation -skip qtlottie -skip qtmacextras -skip qtmultimedia -skip qtnetworkauth -skip qtpurchasing -skip qtquick3d -skip qtquick3dphysics -skip qtquicktimeline -skip qtremoteobjects -skip qtscript -skip qtsensors -skip qtwayland -skip qtwebglplugin -skip qtwebview -skip webengine -nomake examples -nomake tests
+```
+
+* Clone this repo and execute `bueno.bat`.

assets.qrc

@@ -1,5 +1,10 @@
 <!DOCTYPE RCC><RCC version="1.0">
 <qresource prefix="/">
-   <file>assets/notificationAreaIcon.png</file>
+  <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>

assets/style.qss

@@ -0,0 +1,6 @@
+QMainWindow { background: rgba(100,100,100,100); }
+
+
+
+
+QCheckBox:hover, QCheckBox:checked { color: white }

bueno.bat

@@ -1,4 +1,7 @@
-qmake -o build\Makefile .\qtest.pro
+taskkill /F /IM "MixerQ.exe"
-copy /Y /B .\assets\SoundVolumeView.exe .\build\debug
+taskkill /F /IM "MixerQd.exe"
-copy /Y /B .\assets\SoundVolumeView.exe .\build\release
+qmake -o build\Makefile .\qtest.pro 
-mingw32-make.exe -C .\build -f Makefile
+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

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

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

qtest.pro

@@ -1,16 +1,28 @@
-QMAKE_CXXFLAGS += --target=x86_64-w64-mingw32 -g -gcodeview 
+TEMPLATE = app
-QMAKE_LFLAGS += --target=x86_64-w64-mingw32 -g -Wl,-pdb= -v 
+QMAKE_CXXFLAGS += --target=x86_64-w64-mingw32 -Werror=return-type 
-LIBS += -LC:/capybara/libclang/x86_64-w64-mingw32/lib -lWinmm -lodbc32 -lodbccp32 -luuid -loleaut32 -lole32 -lshell32 -ladvapi32 -lcomdlg32 -lwinspool -lgdi32 -luser32 -lkernel32
+QMAKE_LFLAGS += --target=x86_64-w64-mingw32 -v 
-#"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
+CONFIG(release, debug|release) {
-DEFINES += DEBUG QT_LOGGING_TO_CONSOLE=1 WIN32_LEAN_AND_MEAN
+ TARGET = MixerQ
-CONFIG += debug 
+ 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
-INCLUDEPATH += "$$PWD\src" "$$PWD\src\qt" "$$PWD\src\back" "$$PWD\src\cont"
+DEFINES += QT_LOGGING_TO_CONSOLE=1 WIN32_LEAN_AND_MEAN _WIN32_WINNT=0x0602
-DESTPATH += "$$PWD\src" "$$PWD\src\qt" "$$PWD\src\back" "$$PWD\src\cont"
+DEFINES_DEBUG += DEBUG
-VPATH += "$$PWD\src" "$$PWD\src\qt" "$$PWD\src\back" "$$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
 
-#DESTDIR += "build"
+QT += widgets network svg
+INCLUDEPATH += "$$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 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

src/back/backlasses.h

@@ -4,16 +4,52 @@
 #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);
+	Endpoint(IMMDevice* endpoint, IPolicyConfig7* policyConfig, uint64_t idx = 0);
 	//todo: how to forward declare delegate constructors?
-	Endpoint(IMMDevice* endpoint) : Endpoint(endpoint, 0) {};
+	//Endpoint(IMMDevice* endpoint) : Endpoint(endpoint, 0) {};
 	void reloadEndpointChannels();
 	uint64_t getIndex();
 	void setIndex(uint64_t idx);
@@ -22,16 +58,18 @@ class Endpoint {
 	float getVolume(int channel);
 	void setMute(NGuid guid, bool muted);
 	bool getMute();
-	void setState(uint8_t state);
+	void setState(EndpointState state);
-	size_t getState();
+	EndpointState getState();
 	Roles getRoles();
 	void setRoles(Roles role);
 	void assignRoles(Roles role);
 	void removeRoles(Roles role);
 	void setFlow();
 	Flows getFlow();
+	float getPeakVolume();
 	std::wstring getId();
 	std::wstring getName();
+	void updateName();
 	
 	void setVolumeCallback(EndpointVolumeCallback *epc);
 	void removeVolumeCallback(EndpointVolumeCallback *epc);
@@ -42,28 +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;
+	IMMDevice *endpoint;
-	IAudioSessionManager2 *sessionManager;
+	IAudioEndpointVolume *endpointVolume = nullptr;
-	Flows flow;
-	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!
+	//Not implemented in llvm-mingw. Sad! todo: mingw patch
-	 * IAudioMeterInformation *endpointPeakMeter = nullptr;
+	IPolicyConfig7* policyConfig;
-	 */
 };
 
 class EndpointVolumeCallback : public IAudioEndpointVolumeCallback {
@@ -75,16 +119,19 @@ 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 {
  public:
-	//EndpointSituationCallback(IMMDeviceEnumerator *deviceEnumerator, std::vector<Endpoint*> playbackDevices);
+	EndpointSituationCallback(Overseer* os);
 	ULONG AddRef();
 	ULONG Release();
     HRESULT QueryInterface(REFIID riid, VOID **ppvInterface);
@@ -93,25 +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();
-	void fill(IMMDeviceEnumerator *deviceEnumerator, std::vector<Endpoint*> playbackDevices, std::vector<Endpoint*> captureDevices);
  private:
 	ULONG ref = 1;
-	IMMDeviceEnumerator *deviceEnumerator;
+	Overseer* os;
-	std::vector<Endpoint*> playbackDevices;
+	std::atomic<bool> isEpStateChanging = false;
-	std::vector<Endpoint*> captureDevices;
 };
 
 class Overseer {
-	//TODO singleton?
+
  public:
 	Overseer();
+	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();
 	
@@ -123,28 +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;
 };

src/back/backsessionclasses.cpp

@@ -37,6 +37,11 @@ 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;
 }
 
@@ -89,8 +94,10 @@ HRESULT SessionStateCallback::OnStateChanged(AudioSessionState NewState) {
 }
 
 HRESULT SessionStateCallback::OnSessionDisconnected(AudioSessionDisconnectReason DisconnectReason) {
-	sh->setState(SessionState::DISCONNECTED);
+	if (DisconnectReason != DisconnectReasonDeviceRemoval) {
-	sh->reviseSessionShowing(SessionState::DISCONNECTED);
+		sh->setState(SessionState::DISCONNECTED);
+		sh->reviseSessionShowing(SessionState::DISCONNECTED);
+	}
     return S_OK;
 }
 
@@ -98,7 +105,10 @@ Session::Session(Endpoint* ep, IAudioSessionControl2* sessionControl, size_t idx
 	this->ep = ep;
 	this->sessionControl = sessionControl;
 	this->idx = idx;
-
+	//https://matthewvaneerde.wordpress.com/2012/06/08/getting-audio-peak-meter-values-for-all-active-audio-sessions/
+	if (FAILED(sessionControl->QueryInterface(__uuidof(IAudioMeterInformation), (void**)&meterInformation))) { log_wdebugcpp(L"sPeakbros......"); };
+	//meterInformation = (IAudioMeterInformation*)sessionControl;
+	
 	AudioSessionState msState;
 	sessionControl->GetState(&msState);
 	switch (msState) {
@@ -121,10 +131,19 @@ Session::Session(Endpoint* ep, IAudioSessionControl2* sessionControl, size_t idx
 	else {
 		LPWSTR sessionDisplayName;
 		this->sessionControl->GetDisplayName(&sessionDisplayName);
-		if (!wcscmp(sessionDisplayName, L""))	
+		if (!wcscmp(sessionDisplayName, L"")) {
-		   	this->sessionName = this->fetchProcessName(pid);
+			std::wstring exePath;
-		else	
+			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);
 	}
 }
@@ -140,6 +159,13 @@ float Session::getVolume(int channel){
 	return volume;
 }
 
+float Session::getPeakVolume() {
+	float peakVol;
+	if(meterInformation) meterInformation->GetPeakValue(&peakVol);
+	else return 0;
+	return peakVol;
+}
+
 /*
  * uint32_t Endpoint::getChannelCount(){
  * 	return (uint32_t)channelCount;
@@ -150,6 +176,10 @@ std::wstring Session::getName() {
 	return sessionName;
 }
 
+void Session::setName(std::wstring newName) {
+	this->sessionName = newName;
+}
+
 bool Session::getMute() {
 	BOOL mut;
 	if(FAILED(sessionVolume->GetMute(&mut))) { /* TIP: Below */ }
@@ -176,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) {
+bool Session::getExePath(DWORD pid, std::wstring *exePath) {
-	/*
+	//std::wstring msixName;
-	 * https://learn.microsoft.com/en-us/windows/win32/api/tlhelp32/nf-tlhelp32-createtoolhelp32snapshot
+	HANDLE processHandle;
-	 * https://stackoverflow.com/questions/11843368/how-to-get-process-description
+	wchar_t fileName[UNICODE_STRING_MAX_CHARS];
-	 */
+	processHandle = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, pid);
-	
+	if (processHandle != NULL) {
-	/* Executable path retrieval  */
+		if (GetModuleFileNameEx(processHandle, NULL, fileName, UNICODE_STRING_MAX_CHARS) == 0) {
-	std::wstring exePath = L"";
+			CloseHandle(processHandle);
-
+			return false;			 
-	HANDLE processList = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE | TH32CS_SNAPMODULE32, pid);
+		}
-	if (processList == INVALID_HANDLE_VALUE) {
+	} else {
-		log_wdebugcpp(L"aye no procname.");
+		log_wdebugcpp(L"aye no procname. -> " + std::to_wstring(GetLastError()));
-		return exePath;
+		return false;
 	}
 
-	MODULEENTRY32W me32w;
+	*exePath = std::wstring(fileName);
-    me32w.dwSize = sizeof(MODULEENTRY32W);
+	return true;
-    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);
 
-	/* 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);
+	DWORD fileVersionInfoSize = GetFileVersionInfoSizeExW
-	if (!fileVersionInfoSize) return exePath;
+		(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))
+	if(!GetFileVersionInfoExW(FILE_VER_GET_LOCALISED | FILE_VER_GET_NEUTRAL,
-		return exePath;
+							  exePath.c_str(),0,fileVersionInfoSize, fileVersionInfo)) {
+		return false;
+	}
 
 	UINT translationArrayLen = 0;
-	if (!VerQueryValueW(fileVersionInfo, L"\\VarFileInfo\\Translation", (LPVOID*)&translationArray, &translationArrayLen))
+	if (!VerQueryValueW(fileVersionInfo, L"\\VarFileInfo\\Translation", (LPVOID*)&translationArray, &translationArrayLen)) {
-		return exePath;
+		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;
+	int8_t syslangIdx = -1;
-	 for (UINT i = 0; i < (translationArrayLen / sizeof(LANGANDCODEPAGE)); i++) {
+	wchar_t metadataStringKey[256];
-        wchar_t fileDescriptionKey[256];
+	wchar_t* metadataString = NULL;
+	for (UINT i = 0; i < availableLangs; i++) {  
 		LANGID defaultUILanguage = GetUserDefaultUILanguage();
         if (defaultUILanguage != translationArray[i].wLanguage)
 			continue;
 
-		match = true;
+		syslangIdx = i;
-        wchar_t* fileDescription = NULL;
+		break;
-        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);
-        }
     }
 
-	 if (!match && 1 <= (translationArrayLen / sizeof(LANGANDCODEPAGE))) {
+	UINT metadataStringSize = 0;
-		  wchar_t fileDescriptionKey[256];
+	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;
+	if(fileVersionInfo)
-        UINT fileDescriptionSize = 0;
+		free(fileVersionInfo);
-		 swprintf(fileDescriptionKey, L"\\StringFileInfo\\%04x%04x\\FileDescription",
+
-            translationArray[0].wLanguage, translationArray[0].wCodePage);
+	return false;
-        if (VerQueryValueW(fileVersionInfo, fileDescriptionKey, (LPVOID*)&fileDescription, &fileDescriptionSize)) {
+}
-            exePath = std::wstring(fileDescription);
+
-        }
+
-	 }
+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
@@ -277,6 +416,10 @@ void Session::removeStateCallback(SessionStateCallback *ssc){
 }
 
 Session::~Session() {
+	meterInformation->Release();
 	sessionControl->Release();
 	sessionVolume->Release();
+	meterInformation = nullptr;
+	sessionControl	 = nullptr;
+	sessionVolume	 = nullptr;
 }

src/back/backsessionclasses.h

@@ -33,25 +33,32 @@ class Session {
 	Session(Endpoint* ep, IAudioSessionControl2* sessionControl) : Session(ep, sessionControl, SIZE_MAX) {};
 	void setVolume(NGuid guid, int channel, float volume);
 	float getVolume(int channel);
+	float getPeakVolume();
 	void setMute(NGuid guid, bool muted);
 	bool getMute();
 	SessionState getState();
 	void setState(SessionState state);
 	void setIndex(size_t idx);
 	std::wstring getName();
-
+	void setName(std::wstring newName);
 	void setStateCallback(SessionStateCallback *ssc);
 	void removeStateCallback(SessionStateCallback *ssc);
 	~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; 
 };
 

src/back/ipolicyconfig.h

@@ -1,47 +1,42 @@
-// ----------------------------------------------------------------------------
+#pragma once 
-// PolicyConfig.h
+
-// Undocumented COM-interface IPolicyConfig.
+#ifndef __IPolicyConfig7_FWD_DEFINED__
-// Use for set default audio render endpoint
+#define __IPolicyConfig7_FWD_DEFINED__
-// @author EreTIk
+typedef interface IPolicyConfig7 IPolicyConfig7;
-// ----------------------------------------------------------------------------
+#ifdef __cplusplus
+interface IPolicyConfig7;
+#endif
+#endif 	/* __IPolicyConfig7_FWD_DEFINED__ */
+
+#ifndef __CPolicyConfigClient_FWD_DEFINED__
+#define __CPolicyConfigClient_FWD_DEFINED__
+typedef class CPolicyConfigClient CPolicyConfigClient;
+#endif 	/* __CPolicyConfigClient_FWD_DEFINED__ */
+
+/*****************************************************************************
+ * CPolicyConfigClient coclass
+ */
+
+DEFINE_GUID(CLSID_CPolicyConfigClient, 0x870af99c, 0x171d, 0x4f9e, 0xaf,0x0d, 0xe6,0x3d,0xf4,0x0c,0x2b,0xc9);
+#ifdef __cplusplus
+class DECLSPEC_UUID("870af99c-171d-4f9e-af0d-e63df40c2bc9") CPolicyConfigClient;
+#ifdef __CRT_UUID_DECL
+__CRT_UUID_DECL(CPolicyConfigClient, 0x870af99c, 0x171d, 0x4f9e, 0xaf,0x0d, 0xe6,0x3d,0xf4,0x0c,0x2b,0xc9)
+#endif
+#endif
 
 
-#pragma once
+/*****************************************************************************
-
+ * IPolicyConfig7 interface
-
+ */
-interface DECLSPEC_UUID("CA286FC3-91FD-42C3-8E9B-CAAFA66242E3")
+#ifndef __IPolicyConfig7_INTERFACE_DEFINED__
-IPolicyConfig10;
+#define __IPolicyConfig7_INTERFACE_DEFINED__
-
+DEFINE_GUID(IID_IPolicyConfig7, 0xf8679f50, 0x850a, 0x41cf, 0x9c,0x72, 0x43,0x0f,0x29,0x02,0x90,0xc8);
-interface DECLSPEC_UUID("00000000-0000-0000-C000-000000000046")
+#if defined(__cplusplus) && !defined(CINTERFACE)
-IPolicyConfig10_1;
+MIDL_INTERFACE("f8679f50-850a-41cf-9c72-430f290290c8")
-
+IPolicyConfig7 : public IUnknown {
-interface DECLSPEC_UUID("F8679F50-850A-41CF-9C72-430F290290C8")
+	
-IPolicyConfig7;
-
-/* interface DECLSPEC_UUID("568B9108-44BF-40B4-9006-86AFE5B5A620") */
-/* IPolicyConfigVista; */
-
-interface DECLSPEC_UUID("f8679f50-850a-41cf-9c72-430f290290c8")
-IPolicyConfig;
-class DECLSPEC_UUID("870af99c-171d-4f9e-af0d-e63df40c2bc9")
-CPolicyConfigClient;
-// ----------------------------------------------------------------------------
-// class CPolicyConfigClient
-// {870af99c-171d-4f9e-af0d-e63df40c2bc9}
-//
-// interface IPolicyConfig
-// {f8679f50-850a-41cf-9c72-430f290290c8}
-//
-// Query interface:
-// CComPtr<IPolicyConfig> PolicyConfig;
-// PolicyConfig.CoCreateInstance(__uuidof(CPolicyConfigClient));
-//
-// @compatible: Windows 7 and Later
-// ----------------------------------------------------------------------------
-interface IPolicyConfig : public IUnknown
-{
 public:
-
 	virtual HRESULT GetMixFormat(
 		PCWSTR,
 		WAVEFORMATEX **
@@ -107,32 +102,69 @@ public:
 		INT
 	);
 };
+#ifdef __CRT_UUID_DECL
+__CRT_UUID_DECL(IPolicyConfig7, 0xf8679f50, 0x850a, 0x41cf, 0x9c,0x72, 0x43,0x0f,0x29,0x02,0x90,0xc8)
+#endif
+
+#endif
+
+
+#endif  /* __IPolicyConfig7_INTERFACE_DEFINED__ */	
+
+	
+
+
+/* __CRT_UUID_DECL(IPolicyConfig10,     0xca286fc3, 0x91fd, 0x42c3, 0x8e,0x9b, 0xca,0xaf,0xa6,0x62,0x42,0xe3) */
+/* __CRT_UUID_DECL(CPolicyConfigClient, 0x870af99c, 0x171d, 0x4f9e, 0xaf,0x0d, 0xe6,0x3d,0xf4,0x0c,0x2b,0xc9) */
+
 
-/* interface DECLSPEC_UUID("568b9108-44bf-40b4-9006-86afe5b5a620") */
-/* IPolicyConfigVista; */
-/* class DECLSPEC_UUID("294935CE-F637-4E7C-A41B-AB255460B862") */
-/* CPolicyConfigVistaClient; */
 /* // ---------------------------------------------------------------------------- */
-/* // class CPolicyConfigVistaClient */
+/* // PolicyConfig.h */
-/* // {294935CE-F637-4E7C-A41B-AB255460B862} */
+/* // Undocumented COM-interface IPolicyConfig. */
+/* // Use for set default audio render endpoint */
+/* // @author EreTIk */
+/* // ---------------------------------------------------------------------------- */
+
+/* #pragma once */
+
+/* interface DECLSPEC_UUID("CA286FC3-91FD-42C3-8E9B-CAAFA66242E3") */
+/* IPolicyConfig10; */
+
+/* interface DECLSPEC_UUID("00000000-0000-0000-C000-000000000046") */
+/* IPolicyConfig10_1; */
+
+/* interface DECLSPEC_UUID("F8679F50-850A-41CF-9C72-430F290290C8") */
+/* IPolicyConfig7; */
+
+/* /\* interface DECLSPEC_UUID("568B9108-44BF-40B4-9006-86AFE5B5A620") *\/ */
+/* /\* IPolicyConfigVista; *\/ */
+
+/* interface DECLSPEC_UUID("f8679f50-850a-41cf-9c72-430f290290c8") */
+/* IPolicyConfig; */
+
+/* class DECLSPEC_UUID("870af99c-171d-4f9e-af0d-e63df40c2bc9") */
+/* CPolicyConfigClient; */
+/* // ---------------------------------------------------------------------------- */
+/* // class CPolicyConfigClient */
+/* // {870af99c-171d-4f9e-af0d-e63df40c2bc9} */
 /* // */
-/* // interface IPolicyConfigVista */
+/* // interface IPolicyConfig */
-/* // {568b9108-44bf-40b4-9006-86afe5b5a620} */
+/* // {f8679f50-850a-41cf-9c72-430f290290c8} */
 /* // */
 /* // Query interface: */
-/* // CComPtr<IPolicyConfigVista> PolicyConfig; */
+/* // CComPtr<IPolicyConfig> PolicyConfig; */
-/* // PolicyConfig.CoCreateInstance(__uuidof(CPolicyConfigVistaClient)); */
+/* // PolicyConfig.CoCreateInstance(__uuidof(CPolicyConfigClient)); */
 /* // */
-/* // @compatible: Windows Vista and Later */
+/* // @compatible: Windows 7 and Later */
 /* // ---------------------------------------------------------------------------- */
-/* interface IPolicyConfigVista : public IUnknown */
+/* interface IPolicyConfig : public IUnknown */
 /* { */
 /* public: */
 
 /* 	virtual HRESULT GetMixFormat( */
 /* 		PCWSTR, */
 /* 		WAVEFORMATEX ** */
-/* 	);  // not available on Windows 7, use method from IPolicyConfig */
+/* 	); */
 
 /* 	virtual HRESULT STDMETHODCALLTYPE GetDeviceFormat( */
 /* 		PCWSTR, */
@@ -140,6 +172,10 @@ public:
 /* 		WAVEFORMATEX ** */
 /* 	); */
 
+/* 	virtual HRESULT STDMETHODCALLTYPE ResetDeviceFormat( */
+/* 		PCWSTR */
+/* 	); */
+
 /* 	virtual HRESULT STDMETHODCALLTYPE SetDeviceFormat( */
 /* 		PCWSTR, */
 /* 		WAVEFORMATEX *, */
@@ -151,22 +187,22 @@ public:
 /* 		INT, */
 /* 		PINT64, */
 /* 		PINT64 */
-/* 	);  // not available on Windows 7, use method from IPolicyConfig */
+/* 	); */
 
 /* 	virtual HRESULT STDMETHODCALLTYPE SetProcessingPeriod( */
 /* 		PCWSTR, */
 /* 		PINT64 */
-/* 	);  // not available on Windows 7, use method from IPolicyConfig */
+/* 	); */
 
 /* 	virtual HRESULT STDMETHODCALLTYPE GetShareMode( */
 /* 		PCWSTR, */
 /* 		struct DeviceShareMode * */
-/* 	);  // not available on Windows 7, use method from IPolicyConfig */
+/* 	); */
 
 /* 	virtual HRESULT STDMETHODCALLTYPE SetShareMode( */
 /* 		PCWSTR, */
 /* 		struct DeviceShareMode * */
-/* 	);  // not available on Windows 7, use method from IPolicyConfig */
+/* 	); */
 
 /* 	virtual HRESULT STDMETHODCALLTYPE GetPropertyValue( */
 /* 		PCWSTR, */
@@ -181,12 +217,95 @@ public:
 /* 	); */
 
 /* 	virtual HRESULT STDMETHODCALLTYPE SetDefaultEndpoint( */
-/* 		__in PCWSTR wszDeviceId, */
+/* 		PCWSTR wszDeviceId, */
-/* 		__in ERole eRole */
+/* 		ERole eRole */
 /* 	); */
 
 /* 	virtual HRESULT STDMETHODCALLTYPE SetEndpointVisibility( */
 /* 		PCWSTR, */
 /* 		INT */
-/* 	);  // not available on Windows 7, use method from IPolicyConfig */
+/* 	); */
 /* }; */
+
+/* /\* interface DECLSPEC_UUID("568b9108-44bf-40b4-9006-86afe5b5a620") *\/ */
+/* /\* IPolicyConfigVista; *\/ */
+/* /\* class DECLSPEC_UUID("294935CE-F637-4E7C-A41B-AB255460B862") *\/ */
+/* /\* CPolicyConfigVistaClient; *\/ */
+/* /\* // ---------------------------------------------------------------------------- *\/ */
+/* /\* // class CPolicyConfigVistaClient *\/ */
+/* /\* // {294935CE-F637-4E7C-A41B-AB255460B862} *\/ */
+/* /\* // *\/ */
+/* /\* // interface IPolicyConfigVista *\/ */
+/* /\* // {568b9108-44bf-40b4-9006-86afe5b5a620} *\/ */
+/* /\* // *\/ */
+/* /\* // Query interface: *\/ */
+/* /\* // CComPtr<IPolicyConfigVista> PolicyConfig; *\/ */
+/* /\* // PolicyConfig.CoCreateInstance(__uuidof(CPolicyConfigVistaClient)); *\/ */
+/* /\* // *\/ */
+/* /\* // @compatible: Windows Vista and Later *\/ */
+/* /\* // ---------------------------------------------------------------------------- *\/ */
+/* /\* interface IPolicyConfigVista : public IUnknown *\/ */
+/* /\* { *\/ */
+/* /\* public: *\/ */
+
+/* /\* 	virtual HRESULT GetMixFormat( *\/ */
+/* /\* 		PCWSTR, *\/ */
+/* /\* 		WAVEFORMATEX ** *\/ */
+/* /\* 	);  // not available on Windows 7, use method from IPolicyConfig *\/ */
+
+/* /\* 	virtual HRESULT STDMETHODCALLTYPE GetDeviceFormat( *\/ */
+/* /\* 		PCWSTR, *\/ */
+/* /\* 		INT, *\/ */
+/* /\* 		WAVEFORMATEX ** *\/ */
+/* /\* 	); *\/ */
+
+/* /\* 	virtual HRESULT STDMETHODCALLTYPE SetDeviceFormat( *\/ */
+/* /\* 		PCWSTR, *\/ */
+/* /\* 		WAVEFORMATEX *, *\/ */
+/* /\* 		WAVEFORMATEX * *\/ */
+/* /\* 	); *\/ */
+
+/* /\* 	virtual HRESULT STDMETHODCALLTYPE GetProcessingPeriod( *\/ */
+/* /\* 		PCWSTR, *\/ */
+/* /\* 		INT, *\/ */
+/* /\* 		PINT64, *\/ */
+/* /\* 		PINT64 *\/ */
+/* /\* 	);  // not available on Windows 7, use method from IPolicyConfig *\/ */
+
+/* /\* 	virtual HRESULT STDMETHODCALLTYPE SetProcessingPeriod( *\/ */
+/* /\* 		PCWSTR, *\/ */
+/* /\* 		PINT64 *\/ */
+/* /\* 	);  // not available on Windows 7, use method from IPolicyConfig *\/ */
+
+/* /\* 	virtual HRESULT STDMETHODCALLTYPE GetShareMode( *\/ */
+/* /\* 		PCWSTR, *\/ */
+/* /\* 		struct DeviceShareMode * *\/ */
+/* /\* 	);  // not available on Windows 7, use method from IPolicyConfig *\/ */
+
+/* /\* 	virtual HRESULT STDMETHODCALLTYPE SetShareMode( *\/ */
+/* /\* 		PCWSTR, *\/ */
+/* /\* 		struct DeviceShareMode * *\/ */
+/* /\* 	);  // not available on Windows 7, use method from IPolicyConfig *\/ */
+
+/* /\* 	virtual HRESULT STDMETHODCALLTYPE GetPropertyValue( *\/ */
+/* /\* 		PCWSTR, *\/ */
+/* /\* 		const PROPERTYKEY &, *\/ */
+/* /\* 		PROPVARIANT * *\/ */
+/* /\* 	); *\/ */
+
+/* /\* 	virtual HRESULT STDMETHODCALLTYPE SetPropertyValue( *\/ */
+/* /\* 		PCWSTR, *\/ */
+/* /\* 		const PROPERTYKEY &, *\/ */
+/* /\* 		PROPVARIANT * *\/ */
+/* /\* 	); *\/ */
+
+/* /\* 	virtual HRESULT STDMETHODCALLTYPE SetDefaultEndpoint( *\/ */
+/* /\* 		__in PCWSTR wszDeviceId, *\/ */
+/* /\* 		__in ERole eRole *\/ */
+/* /\* 	); *\/ */
+
+/* /\* 	virtual HRESULT STDMETHODCALLTYPE SetEndpointVisibility( *\/ */
+/* /\* 		PCWSTR, *\/ */
+/* /\* 		INT *\/ */
+/* /\* 	);  // not available on Windows 7, use method from IPolicyConfig *\/ */
+/* /\* }; *\/ */

src/back/msinclude.h

@@ -1,17 +1,23 @@
 #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>
 #include <initguid.h>
 #include <Propidl.h>
+#include <propsys.h>
 #include <functiondiscoverykeys_devpkey.h>
+#include <psapi.h>
 //#include <debugapi.h>
 
 #include <endpointvolume.h>
@@ -21,6 +27,38 @@
 //#include <comip.h>
 #include <Winerror.h>
 #include <stringapiset.h>
-#include "ipolicyconfig.h"
 #include <Mmreg.h>
 #include <tlhelp32.h>
+#include <Knownfolders.h>
+
+#include "ipolicyconfig.h"
+#include "audiometerinfo.h"
+
+//  IAudioMeterInformation
+/*  GUID manual; */
+/* 	manual.Data1 = 0xc02216f6; */
+/* 	manual.Data2 = 0x8c67; */
+/* 	manual.Data3 = 0x4b5b; */
+/* 	manual.Data4[0] = 0x9d;  */
+/* 	manual.Data4[1] = 0x00;  */
+/* 	manual.Data4[2] = 0xd0;  */
+/* 	manual.Data4[3] = 0x08;  */
+/* 	manual.Data4[4] = 0xe7;  */
+/* 	manual.Data4[5] = 0x3e;  */
+/* 	manual.Data4[6] = 0x00; */
+/* 	manual.Data4[7] = 0x64; */
+//if(FAILED(endpoint->Activate((const _GUID) manual,
+
+//IMMEndpoint
+/* GUID manual; */
+/* manual.Data1 = 0x1be09788; */
+/* manual.Data2 = 0x6894; */
+/* manual.Data3 = 0x4089; */
+/* manual.Data4[0] = 0x85;  */
+/* manual.Data4[1] = 0x86;  */
+/* manual.Data4[2] = 0x9a;  */
+/* manual.Data4[3] = 0x2a;  */
+/* manual.Data4[4] = 0x6c;  */
+/* manual.Data4[5] = 0x26;  */
+/* manual.Data4[6] = 0x5a; */
+/* manual.Data4[7] = 0xc5;   */

src/back/reimpl/audiometerinfo.h

@@ -0,0 +1,130 @@
+#ifndef __IAudioMeterInformation_FWD_DEFINED__
+#define __IAudioMeterInformation_FWD_DEFINED__
+typedef interface IAudioMeterInformation IAudioMeterInformation;
+
+#endif 	/* __IAudioMeterInformation_FWD_DEFINED__ */
+
+#ifdef __cplusplus
+extern "C"{
+#endif 
+
+/* interface __MIDL_itf_endpointvolume_0000_0003 */
+/* [local] */ 
+
+#ifndef __IAudioMeterInformation_INTERFACE_DEFINED__
+#define __IAudioMeterInformation_INTERFACE_DEFINED__
+
+/* interface IAudioMeterInformation */
+/* [unique][helpstring][nonextensible][uuid][local][object] */ 
+
+DEFINE_GUID(IID_IAudioMeterInformation, 0xc02216f6, 0x8c67, 0x4b5b, 0x9d,0x00, 0xd0,0x08,0xe7,0x3e,0x00,0x64);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("c02216f6-8c67-4b5b-9d00-d008e73e0064")
+    IAudioMeterInformation : public IUnknown
+    {
+    public:
+        virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE GetPeakValue( 
+            /* [out] */ float *pfPeak) = 0;
+        
+        virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE GetMeteringChannelCount( 
+            /* [annotation][out] */ 
+            _Out_  UINT *pnChannelCount) = 0;
+        
+        virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE GetChannelsPeakValues( 
+            /* [in] */ UINT32 u32ChannelCount,
+            /* [size_is][out] */ float *afPeakValues) = 0;
+        
+        virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE QueryHardwareSupport( 
+            /* [annotation][out] */ 
+            _Out_  DWORD *pdwHardwareSupportMask) = 0;
+        
+    };
+    
+#ifdef __CRT_UUID_DECL
+__CRT_UUID_DECL(IAudioMeterInformation, 0xc02216f6, 0x8c67, 0x4b5b, 0x9d,0x00, 0xd0,0x08,0xe7,0x3e,0x00,0x64)
+#endif
+#else 	/* C style interface */
+
+    typedef struct IAudioMeterInformationVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IAudioMeterInformation * This,
+            /* [in] */ REFIID riid,
+            /* [annotation][iid_is][out] */ 
+            _COM_Outptr_  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IAudioMeterInformation * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IAudioMeterInformation * This);
+        
+        /* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *GetPeakValue )( 
+            IAudioMeterInformation * This,
+            /* [out] */ float *pfPeak);
+        
+        /* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *GetMeteringChannelCount )( 
+            IAudioMeterInformation * This,
+            /* [annotation][out] */ 
+            _Out_  UINT *pnChannelCount);
+        
+        /* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *GetChannelsPeakValues )( 
+            IAudioMeterInformation * This,
+            /* [in] */ UINT32 u32ChannelCount,
+            /* [size_is][out] */ float *afPeakValues);
+        
+        /* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *QueryHardwareSupport )( 
+            IAudioMeterInformation * This,
+            /* [annotation][out] */ 
+            _Out_  DWORD *pdwHardwareSupportMask);
+        
+        END_INTERFACE
+    } IAudioMeterInformationVtbl;
+
+    interface IAudioMeterInformation
+    {
+        CONST_VTBL struct IAudioMeterInformationVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IAudioMeterInformation_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IAudioMeterInformation_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IAudioMeterInformation_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IAudioMeterInformation_GetPeakValue(This,pfPeak)	\
+    ( (This)->lpVtbl -> GetPeakValue(This,pfPeak) ) 
+
+#define IAudioMeterInformation_GetMeteringChannelCount(This,pnChannelCount)	\
+    ( (This)->lpVtbl -> GetMeteringChannelCount(This,pnChannelCount) ) 
+
+#define IAudioMeterInformation_GetChannelsPeakValues(This,u32ChannelCount,afPeakValues)	\
+    ( (This)->lpVtbl -> GetChannelsPeakValues(This,u32ChannelCount,afPeakValues) ) 
+
+#define IAudioMeterInformation_QueryHardwareSupport(This,pdwHardwareSupportMask)	\
+    ( (This)->lpVtbl -> QueryHardwareSupport(This,pdwHardwareSupportMask) ) 
+
+#endif /* COBJMACROS */
+
+#endif 	/* C style interface */
+
+#endif 	/* __IAudioMeterInformation_INTERFACE_DEFINED__ */
+
+#ifdef __cplusplus
+}
+#endif
+
+
+

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,17 +125,21 @@ 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);
 }
 
+float EndpointHandler::getPeakVolume() {
+	return ep->getPeakVolume();
+}
+
 uint8_t EndpointHandler::getRoles(){
 	return ep->getRoles();
 }
@@ -175,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);
 }
 
@@ -190,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);
@@ -201,6 +256,46 @@ 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() {
+	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() {
 	return this->os->getPlaybackEndpoints();
 }
@@ -225,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*>;
@@ -233,9 +328,7 @@ void OverseerHandler::reloadEndpointHandlers(){
 	
 	for(uint64_t i = 0; i < this->getPlaybackEndpointsCount(); i++){
 		log_debugcpp("Creating Playback handler " + std::to_string(i));
-				
+		new EndpointHandler(i, Flows::FLOW_PLAYBACK);
-		EndpointHandler* ephexx = new EndpointHandler(i, Flows::FLOW_PLAYBACK);
-		//this->playbackEndpointHandlers.push_back(ephexx);
 		log_debugcpp("Created Playback  handler " + std::to_string(i) + ", adding to vector. " + " VSize: " + std::to_string(this->playbackEndpointHandlers.size()));
 		
 	}
@@ -243,55 +336,71 @@ 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));
-		
+		new EndpointHandler(i, Flows::FLOW_CAPTURE);
-		/*
-		 * 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);
 		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) {
+void OverseerHandler::setRoleBucketEntryFunction(std::function<void(Roles, std::wstring)> roleBucketEntry) {
-	this->changeFrontDefaults(role, endpointId);
+	this->roleBucketEntry = roleBucketEntry;
+}
+
+void OverseerHandler::updateFrontEndpointName(Endpoint* ep) {
+	//todo: reintroduce capture devices
+	for (auto eph : playbackEndpointHandlers) {
+		if (eph->getEndpoint() == ep) eph->getCallbackInfo()->updateName = true;
+	}
 }
 
 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;
@@ -305,22 +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;
-		//return;
 		//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;
 }
 
@@ -335,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();
+}
+

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,21 +17,21 @@ 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:
 	EndpointHandler(uint64_t idx, Flows flow);
 	void setBackEndpointVolumeCallbackInfoContent(uint8_t state);
 
-	//these two, currently unused. If I use them, I should feel bad.
+	//todo: replace all getEndpointHandler()
-	//EndpointVolumeCallback* getEndpointVolumeCallback();
+	//todo: name refactor
-	//Endpoint* getEndpoint();
-	
-	//std::wstring epName;
 	BackEndpointVolumeCallbackInfo* getCallbackInfo();
 	uint32_t getChannelCount();
 	
@@ -39,6 +40,7 @@ public:
 	void setVolume(int channel, float volume);
 	
 	std::wstring getName();
+	void setName(std::wstring newName);
 	std::wstring getId();
 
 	void setFrontVisibilityInfo(EndpointState state, uint64_t frontIdx);
@@ -56,9 +58,10 @@ public:
 	
 	void setVolume(NGuid guid, int channel, int value);
 	void setMute(NGuid guid, bool muted);
-	void setState(uint8_t state);
+	void setState(EndpointState state);
-	void setState(uint8_t state, uint64_t idx);
+	void setState(EndpointState state, uint64_t idx);
 
+	float getPeakVolume();
 	/* sessions */
 	size_t getSessionCount();
 	std::vector<SessionHandler*> getSessionHandlers();
@@ -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,9 +107,25 @@ class OverseerHandler {
 
 public:
 	OverseerHandler();
-	void setChangeFrontDefaultsFunction(std::function<void(Roles, std::wstring)> changeFrontDefaults);
+	static void setSettingsPath(std::string path);
-	void changeFrontDefaultsCallback(Roles role, std::wstring endpointId);
+	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 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);
 	void setRemoveEndpointWidgetFunction(std::function<void(uint64_t)> removeEndpointWidget);
@@ -113,25 +139,29 @@ public:
 	void pushBackEndpointHandler(EndpointHandler* eph, Flows flow);
 	uint64_t getPlaybackEndpointsCount();
 	uint64_t getCaptureEndpointsCount();
-	void reloadEndpointHandlers();
+	void createEndpointHandlers();
-	EndpointHandler* addEndpoint(std::wstring endpointId, Flows *flow); 
+	EndpointHandler* addEndpoint(std::wstring endpointId, Flows *flow);
+	void reportFinishedStateChange();
 	NGuid getGuid();
 
-	/*
+	std::mutex handlersPlaybackMutex;
-	 * void setSessionVolumeCallback(std::function<void(float)> changeSessionVolume);
+	std::mutex handlersCaptureMutex;
-	 * void setSessionVolume(float newValue, ); 
+	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;
 	

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();
@@ -32,6 +32,14 @@ std::wstring SessionHandler::getName(){
 	return session->getName();
 }
 
+void SessionHandler::setName(std::wstring newName){
+	session->setName(newName);
+}
+
+float SessionHandler::getPeakVolume(){
+	return session->getPeakVolume();
+}
+
 bool SessionHandler::getMute(){
     return session->getMute();
 }
@@ -77,3 +85,7 @@ void SessionHandler::reviseSessionShowing(SessionState state) {
 	}
 }
 
+SessionHandler::~SessionHandler() {
+	session->removeStateCallback(ssc);
+	ssc->Release();
+}

src/cont/contsessionclasses.h

@@ -9,10 +9,10 @@ class SessionStateCallback;
 
 struct SessionVolumeInfo {
 	//SessionVolumeInfo(bool muted, float mainVolume);
-	bool  muted;
+	bool 			  muted;
-	float mainVolume;
+	float			  mainVolume;
-	NGuid caller;
+	NGuid			  caller;
-	
+	std::atomic<bool> isNameChanged = false;
 	//size_t  channels;
 	//std::vector<float> channelVolumes;
 };
@@ -29,9 +29,11 @@ class SessionHandler {
 	void setState(SessionState state);
 	uint64_t getFrontIndex();
 	std::wstring getName();
+	float getPeakVolume();
+	void setName(std::wstring newName);
 	void reviseSessionShowing(SessionState state);
 	SessionVolumeInfo* getVolumeInfo();
-	
+	~SessionHandler();
  private:
 	SessionVolumeInfo svi;
 	EndpointHandler* eph;

src/debug.h

@@ -2,11 +2,38 @@
 
 #if defined (QT_DEBUG) || defined (DEBUG) || defined (_DEBUG)
 
-template<size_t Y, typename T> 
+#define PIPE_NAME "Mixerq-dev"
-std::bitset<Y> varToBitset(T info) {
+
-        std::bitset<Y> content(info);  
+#ifdef INIT_FILELOG
+    std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t> converter;
+	FILE* fileLog;
+	errno_t lfResult;
+	bool writable = false;
+	
+	void inline initializeFileLogging() {
+		lfResult = fopen_s(&fileLog, "log.txt", "w");
+		if (!lfResult) writable = true;
+		else writable = false;
+	}
+
+#else
+    extern std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t> converter;
+	extern errno_t lfResult;
+	extern FILE* fileLog;
+	extern bool writable;
+	extern bool initializeFileLogging();
+#endif
+
+#define initialize_file_log() initializeFileLogging()
+
+template<typename T> 
+std::bitset<sizeof(T) * 8> varToBitset(T info) {
+        std::bitset<sizeof(T) * 8> content(info);  
         return content;  
-} 
+}
+
+#define print_as_binary(info)  varToBitset<decltype(info)>(info).to_string()
+
 #ifndef _WIN32
 #define log_debugcpp(str) do {											\
 	 std::cout << "[DEBUG]" << "(" << __FILE__ << ":" << __LINE__ << "): " << str << std::endl; \
@@ -15,6 +42,7 @@ std::bitset<Y> varToBitset(T info) {
 #define log_wdebugcpp(str) do {											\
 	 std::wcout << "[DEBUG]" << "(" << __FILE__ << ":" << __LINE__ << "): " << str << std::endl; \
 	} while (0)
+
 #else
 
 #include <Windows.h>
@@ -29,19 +57,30 @@ std::bitset<Y> varToBitset(T info) {
 #define log_wdebugcpp(str) do {	\
 		OutputDebugStringW(std::wstring(L"[DEBUG] (" +  std::wstring(WFILE) + L":" + std::to_wstring(__LINE__) + L"): " + std::wstring(str) +L"\n").c_str()); \
 	} while (0)
-#endif
 
-#define print_as_binary(len, type, info)  varToBitset<len, type>(info)
+#endif //_WIN32
+
+#define log_to_file(fmt, cnt...)  do {				\
+	if(writable) fprintf_s(fileLog, fmt,##cnt); 	\
+} while (0)
+
+#define close_file_log_buffer() do { \
+	if(writable) { fflush(fileLog); fclose(fileLog); }	\
+} while (0)
 
 #else 
 #define log_debugcpp(str)
 #define log_wdebugcpp(str)
-#define print_as_binary(len, type, info)
+#define print_as_binary(info)
-#endif
+#define log_to_file(fmt, cnt...)
+#define initialize_file_log() false
+#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); */
-/* typedef void (EndpointWidget::*epwMainVolumeFunc)(float newValue); */
+/* Typedef void (EndpointWidget::*epwMainVolumeFunc)(float newValue); */
 /* typedef void (EndpointWidget::*epwChannelVolumeFunc)(uint32_t channel, float newValue); */
 /* typedef void (EndpointWidget::*epwToggleFrontFunc)(bool active); */
 

src/global.h

@@ -1,15 +1,26 @@
 #pragma once
 
+#define __STDC_WANT_LIB_EXT1__ 1
+#include <stdio.h>
+#include <errno.h>
+#include <limits.h>
+#include <codecvt>
 #include <vector>
 #include <iostream>
 #include <string>
 #include <bitset>
-#include <climits>
 #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"
@@ -22,8 +33,29 @@
 
 #define STRING_SYSTEM_SOUNDS "System Sounds"
 #define LSTRING_SYSTEM_SOUNDS L"System Sounds"
+
+#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),
@@ -75,8 +107,11 @@ struct NGuid {
 	/* 	}while (i < 8); */
 	/* } */
 };
+namespace ini {
+	class UserSettings;
+}
 
-
+extern ini::UserSettings *set;
 class OverseerHandler;
 extern OverseerHandler *osh;
 

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;
+};

src/qt/qtclasses.h

@@ -1,67 +1,32 @@
 #pragma once
 
-#ifndef MAINWINDOW_H
+#include "qtcommon.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>
-/*
- * #else
- * class QSlider;
- * class QLabel;
- * class QGridLayout;
- * class QPushButton;
- * class QWidget;
- * class QMainWindow;
- * #endif
- */
-
-#include "global.h"
 #include "contclasses.h"
-//class EndpointHandler;
+#include "settings.h"
+
+class MeterSlider;
+
+enum SpawnPos {
+	LEFT  = (1 << 1),
+	RIGHT = (0 << 1),
+	UP    = (1 << 0),
+	DOWN  = (0 << 0)
+};
 
-/*
- * class ToggleButton : public QAbstractButton {
- * 	Q_OBJECT
- * 
- * public:
- * 	ToggleButton(QWidget *parent = nullptr);
- * 	void 	checkStateSet();
- * 	bool 	hitButton(const QPoint &pos) const;
- * 	void 	nextCheckState();
- * 	void 	changeEvent(QEvent *e) override;
- * 	bool 	event(QEvent *e) override;
- * 	void 	focusInEvent(QFocusEvent *e) override;
- * 	void 	focusOutEvent(QFocusEvent *e) override;
- * 	void 	keyPressEvent(QKeyEvent *e) override;
- * 	void 	keyReleaseEvent(QKeyEvent *e) override;
- * 	void 	mouseMoveEvent(QMouseEvent *e) override;
- * 	void 	mousePressEvent(QMouseEvent *e) override;
- * 	void 	mouseReleaseEvent(QMouseEvent *e) override;
- * 	void 	paintEvent(QPaintEvent *e) override = 0;
- * 	void 	timerEvent(QTimerEvent *e) override;
- * 	ToggleButton(QWidget *parent = nullptr);
- * };
- */
 enum CustomQEvent {
 	EndpointWidgetObsolete = 1001,
 	EndpointWidgetCreated  = 1002,	
 	EndpointDefaultChange  = 1003,
 	SessionWidgetCreated   = 1004,
-	SessionWidgetObsolete  = 1005
+	SessionWidgetObsolete  = 1005,
+	RecomposeMainWindow    = 1006,
+	EndpointRoleChange     = 1007
+};
+
+class DarkModeEventFilter : public QAbstractNativeEventFilter {
+	
+public:
+    bool nativeEventFilter(const QByteArray &eventType, void *message, qintptr *) override;
 };
 
 template <typename T>
@@ -70,57 +35,86 @@ class CustomWidgetEvent : public QEvent {
 public:
 	CustomWidgetEvent(QEvent::Type type, T payload);
 	T payload;
-	
 };	
 //Q_DECLARE_METATYPE(EndpointWidgetEvent)
 
 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
 
 public:
 	SessionWidget(uint64_t idx, SessionHandler* sh, QWidget *parent /* = nullptr */);
 	~SessionWidget();
-																					
+	void calculateSize(uint64_t width, uint64_t height);
+	std::wstring getName();
+						  
 public slots:
 	void updateMainVolume(int newValue);
 	void updateMute(int checked);
 	
 private:
 	QLabel *mainLabel = nullptr;
-	QSlider *mainSlider = nullptr;
+	MeterSlider *mainSlider = nullptr;
 	uint64_t idx;
-	QGridLayout *layout = nullptr;
+	QHBoxLayout *widgetLayout = nullptr;
-	QCheckBox *muteButton = nullptr; 
+	ExtendedCheckBox *muteButton = nullptr; 
 	SessionHandler* sh;
 	QTimer* volumePoller = nullptr;
+	QSpacerItem* widthSpacer;
+};
+
+class ChannelWidget : public QWidget {
+Q_OBJECT
+	  	  
+public:
+	ChannelWidget(uint32_t channelCount, EndpointHandler* eph, QWidget *parent = nullptr);
+	//QSize minimumSizeHint() const override;
+	//void setMinimum(QSize minimum);
+	void updateChannel(int channel);
+	uint32_t getChannelCount() const;
+	
+private:
+	const double roundingFactor = 0.005;
+	EndpointHandler* eph;
+	uint32_t channelCount;
+	std::vector<QSlider*> channelSliders;
+	std::vector<QLabel*> channelLabels;
+	QGridLayout *widgetLayout;
+	QSize minimum;
 };
 
 class EndpointWidget : public QWidget {
 Q_OBJECT
 	  	  
 public:
-	EndpointWidget(uint64_t idx, EndpointHandler* eph, QWidget *parent = nullptr);
+	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();
-
+	
 	void setIndex(uint64_t idx);
 	uint64_t getIndex();
-	void setVolume(int channel, float volume);
+	//void setVolume(int channel, float volume);
-
+	void calculateSize(uint64_t width, uint64_t height);
+	
 	~EndpointWidget();
 	//void updateMainVolume(float newValue);
 	//void updateVolume(uint32_t channel, float newValue);
@@ -128,7 +122,10 @@ public:
 	
 	//void populateEndpointWidget(EndpointHandler *eph);
 	//void setEndpointHandlers(std::vector<EndpointHandler*> *ephs);
-							   
+	
+//protected:
+	//bool event(QEvent* ev) override;
+					 
 public slots:
 	void updateMainVolume(int newValue);
 	void updateMute(int checked);
@@ -142,12 +139,14 @@ private slots:
 
 private:
 	int row;
+	const int sessionCol = 2; 
 	QCheckBox *muteButton = nullptr; 
-	QLabel *mainLabel = nullptr, *leftChannelLabel = nullptr, *rightChannelLabel = nullptr;
+	QLabel *mainLabel = nullptr;
-	QSlider *mainSlider = nullptr;
+	QLabel *mainVolumeLabel = nullptr;
+	MeterSlider *mainSlider = nullptr;
 	std::vector<QSlider*> channelSliders;
 	std::vector<QLabel*> channelLabels;
-	QGridLayout *layout = nullptr;
+	QGridLayout *widgetLayout = nullptr;
 	QGridLayout *mainMuteLayout = nullptr;
 	std::map<Roles, ExtendedCheckBox*> defaultRolesCheckBoxes;	
 	
@@ -155,7 +154,9 @@ private:
 	size_t defaultRolesVectorSize = 4;
 	QTimer* timer = nullptr;
 	uint64_t idx;
+	ChannelWidget* cw = nullptr;
 	std::vector<SessionWidget*> sessionWidgets;
+	QSize minimum;
 	//std::vector<EndpointHandler*> *ephs;
 	//std::vector<QSlider> *sliders;
 	
@@ -164,6 +165,22 @@ private:
 
 };
 
+class HeaderWidget : public QWidget {
+Q_OBJECT
+	  	  
+public:
+	HeaderWidget(QWidget *parent = nullptr);
+
+private:
+	QGridLayout *widgetLayout;
+	//QPushButton *about;
+	#ifdef WIN32
+	QPushButton *openCP;
+	QCheckBox   *startup;
+	QCheckBox   *channels;
+	#endif
+};
+
 class MainWindow : public QMainWindow {
 	Q_OBJECT
 	//QWidget *centralWidget;
@@ -171,11 +188,16 @@ class MainWindow : public QMainWindow {
 public:
 	MainWindow(QWidget *parent = nullptr);
 	void reloadEndpointWidgets();
+	void compose(bool isVisible);
+	void updateColor(uint8_t r, uint8_t g, uint8_t b, uint8_t a);
 
 protected:
 	void closeEvent(QCloseEvent *event) override;	
 	void customEvent(QEvent* ev) override;
-					
+	QRect setSizePosition(QScreen* screen, int width, int height);
+	QScreen* getCurrentScreen();											
+	void createLayout(QGridLayout *newLayout);
+					   
 private slots:
 	void trayIconActivated(QSystemTrayIcon::ActivationReason reason);
 	void removeEndpointWidget(CustomWidgetEvent<uint64_t>* ev);
@@ -186,15 +208,37 @@ 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;
-	QGridLayout *layout;
+	std::mutex roleBucketMutex;
+	QWidget *containerWidget;
+	QGridLayout *widgetLayout;
 
 	QSystemTrayIcon *trayIcon;
     QMenu *trayIconMenu;
 	QAction *trayIconMenuQuit;
+	QAction *trayIconMenuOpenCP;
 	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;
+	
+	QScrollArea *scrollArea;
+	HeaderWidget* hw;
+	QToolBar *mainMenuBar;
+	QScreen *screen;
+	QSpacerItem* lastRowSpacer;
+	QLabel* noEndpoints = nullptr;
+
+	QFont font;
+	friend class EndpointWidget;
 	//public slots:
 	//	void setEndpointHandlers(std::vector<EndpointHandler*> *ephs);
 	
@@ -202,5 +246,3 @@ private:
     //void valueChanged(int value);
 
 };
-
-#endif

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();
+	}
+
+}
+

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::
+

src/qtestmain.cpp

@@ -1,27 +1,22 @@
-//#include <stdio.h>
-//#include <stdlib.h>
-
-//#include <qapplicationstatic.h> 
-
-//#define QTBLESSED
-#include <QApplication>
-#include <QMainWindow>
-
-#include <QLocalSocket>
-#include <QLocalServer>
-#include <QString>
 //#include "contclasses.h"
+#define INIT_FILELOG
+#include "qtcommon.h"
 #include "qtclasses.h"
-#include "global.h"
+#include "qtvisuals.h"
+#include "settings.h"
 
-OverseerHandler *osh = nullptr; 
+OverseerHandler *osh = nullptr;
-	
+ini::UserSettings *set = nullptr;
-QApplication* createApplication(int &argc, char *argv[])
+
-{
+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();
@@ -29,36 +24,122 @@ 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);
 	return server;
 }
 
+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();
+ * 	abort();
+ * }
+ */
+
 int main (int argc, char* argv[]) {
-	//QApplication::setStyle("windowsvista");
+	/*
+	 * Debug: logging report file
+	 */
+	initialize_file_log();
+	atexit(closeDebugFileLog);
+
+	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 (!isSingleInstanceRunning("Mixer"))
+	if (!isInstanceRunning(PIPE_NAME))
-		startSingleInstanceServer("Mixer");
+		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.setEndpointHandlers(ephs);
+	//window.setSizePolicy(QSizePolicy::Fixed, QSizePolicy::QSizePolicy::MinimumExpanding)
 	QApplication::setQuitOnLastWindowClosed(false);
-	app->setStyle("windowsvista");
+
-	window.show();
+	DarkModeEventFilter* darkMode = new DarkModeEventFilter();
+	QAbstractEventDispatcher::instance()->installNativeEventFilter(darkMode);
+	
+	/*
+	 * QFile styleFile(":/assets/style.qss");
+	 * styleFile.open(QFile::ReadOnly);
+	 * QString styleSheet { QLatin1String(styleFile.readAll()) };
+	 */
+
 	return app->exec();	
 }
 

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
+	}
+
+}

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";
+};
+
+}