Fix plugin state and timer action not being translated

Allows you to check for the amount and name of the connected displays

.gitmodules

@@ -16,3 +16,6 @@
 [submodule "deps/tesseract"]
 	path = deps/tesseract
 	url = https://github.com/tesseract-ocr/tesseract.git
+[submodule "deps/libremidi"]
+	path = deps/libremidi
+	url = https://github.com/jcelerier/libremidi.git

CMakeLists.txt

@@ -42,21 +42,20 @@ target_sources(
           src/general.cpp
           src/hotkey.cpp
           src/hotkey.hpp
-          src/hotkey.hpp
           src/platform-funcs.hpp
-          src/scene-group.cpp
-          src/scene-group.hpp
           src/status-control.cpp
           src/status-control.hpp
-          src/switcher-data-structs.cpp
-          src/switcher-data-structs.hpp
+          src/switcher-data.cpp
+          src/switcher-data.hpp
           src/version.cpp
           src/version.h)
 
 # Legacy function sources
 target_sources(
   ${LIB_NAME}
-  PRIVATE src/legacy/scene-trigger.cpp
+  PRIVATE src/legacy/scene-group.cpp
+          src/legacy/scene-group.hpp
+          src/legacy/scene-trigger.cpp
           src/legacy/scene-trigger.hpp
           src/legacy/switch-audio.cpp
           src/legacy/switch-audio.hpp
@@ -74,7 +73,6 @@ target_sources(
           src/legacy/switch-network.hpp
           src/legacy/switch-pause.cpp
           src/legacy/switch-pause.hpp
-          src/legacy/switch-priority.cpp
           src/legacy/switch-random.cpp
           src/legacy/switch-random.hpp
           src/legacy/switch-screen-region.cpp
@@ -109,6 +107,8 @@ target_sources(
           src/macro-core/macro-action-macro.hpp
           src/macro-core/macro-action-media.cpp
           src/macro-core/macro-action-media.hpp
+          src/macro-core/macro-action-osc.cpp
+          src/macro-core/macro-action-osc.hpp
           src/macro-core/macro-action-plugin-state.cpp
           src/macro-core/macro-action-plugin-state.hpp
           src/macro-core/macro-action-profile.cpp
@@ -165,6 +165,8 @@ target_sources(
           src/macro-core/macro-condition-cursor.hpp
           src/macro-core/macro-condition-date.cpp
           src/macro-core/macro-condition-date.hpp
+          src/macro-core/macro-condition-display.cpp
+          src/macro-core/macro-condition-display.hpp
           src/macro-core/macro-condition-edit.cpp
           src/macro-core/macro-condition-edit.hpp
           src/macro-core/macro-condition-file.cpp
@@ -250,8 +252,11 @@ target_sources(
           src/utils/duration-control.hpp
           src/utils/item-selection-helpers.cpp
           src/utils/item-selection-helpers.hpp
+          src/utils/log-helper.hpp
           src/utils/file-selection.cpp
           src/utils/file-selection.hpp
+          src/utils/filter-selection.cpp
+          src/utils/filter-selection.hpp
           src/utils/macro-list.cpp
           src/utils/macro-list.hpp
           src/utils/math-helpers.cpp
@@ -261,6 +266,12 @@ target_sources(
           src/utils/name-dialog.cpp
           src/utils/name-dialog.hpp
           src/utils/obs-dock.hpp
+          src/utils/obs-module-helper.cpp
+          src/utils/obs-module-helper.hpp
+          src/utils/osc-helpers.cpp
+          src/utils/osc-helpers.hpp
+          src/utils/priority-helper.cpp
+          src/utils/priority-helper.hpp
           src/utils/process-config.cpp
           src/utils/process-config.hpp
           src/utils/regex-config.cpp
@@ -271,6 +282,8 @@ target_sources(
           src/utils/scene-item-selection.hpp
           src/utils/scene-selection.cpp
           src/utils/scene-selection.hpp
+          src/utils/scene-switch-helpers.cpp
+          src/utils/scene-switch-helpers.hpp
           src/utils/screenshot-helper.cpp
           src/utils/screenshot-helper.hpp
           src/utils/section.cpp
@@ -283,6 +296,8 @@ target_sources(
           src/utils/string-list.hpp
           src/utils/striped-frame.cpp
           src/utils/striped-frame.hpp
+          src/utils/sync-helper.cpp
+          src/utils/sync-helper.hpp
           src/utils/transition-selection.cpp
           src/utils/transition-selection.hpp
           src/utils/utility.cpp

data/locale/de-DE.ini

@@ -219,7 +219,7 @@ AdvSceneSwitcher.condition.stream.state.start="Stream läuft"
 AdvSceneSwitcher.condition.stream.state.stop="Stream gestoppt"
 AdvSceneSwitcher.condition.stream.state.starting="Stream wird gestartet"
 AdvSceneSwitcher.condition.stream.state.stopping="Stream wird gestoppt"
-AdvSceneSwitcher.condition.stream.entry="{{streamState}}"
+AdvSceneSwitcher.condition.stream.entry="{{streamState}}{{keyFrameInterval}}"
 AdvSceneSwitcher.condition.record="Aufnahme"
 AdvSceneSwitcher.condition.record.state.start="Aufnahme läuft"
 AdvSceneSwitcher.condition.record.state.pause="Aufnahme pausiert"
@@ -428,7 +428,7 @@ AdvSceneSwitcher.action.recording.type.unpause="Aufnahme nicht mehr pausieren"
 AdvSceneSwitcher.action.recording.type.split="Aufnahme-Datei teilen"
 AdvSceneSwitcher.action.recording.pause.hint="Bitte beachten, dass je nach Aufnahmeeinstellung die Aufnahme möglicherweise nicht unterbrochen werden kann"
 AdvSceneSwitcher.action.recording.split.hint="Vergewissern, dass die automatische Dateiaufteilung in den OBS-Einstellungen aktiviert ist!"
-AdvSceneSwitcher.action.recording.entry="{{actions}}{{pauseHint}}{{splitHint}}"
+AdvSceneSwitcher.action.recording.entry="{{actions}}{{recordFolder}}{{recordFileFormat}}{{pauseHint}}{{splitHint}}"
 AdvSceneSwitcher.action.replay="Replay Buffer"
 AdvSceneSwitcher.action.replay.saveWarn="Warnung: Ein zu häufiges Speichern kann dazu führen, dass der Replay Buffer nicht gespeichert wird!"
 AdvSceneSwitcher.action.replay.type.stop="Replay Buffer stoppen"
@@ -438,7 +438,7 @@ AdvSceneSwitcher.action.replay.entry="{{actions}}"
 AdvSceneSwitcher.action.streaming="Stream"
 AdvSceneSwitcher.action.streaming.type.stop="Stream stoppen"
 AdvSceneSwitcher.action.streaming.type.start="Stream starten"
-AdvSceneSwitcher.action.streaming.entry="{{actions}}"
+AdvSceneSwitcher.action.streaming.entry="{{actions}}{{keyFrameInterval}}"
 AdvSceneSwitcher.action.run="Ausführen"
 AdvSceneSwitcher.action.run.arguments="Argumente:"
 AdvSceneSwitcher.action.run.addArgument="Argument hinzufügen"
@@ -545,7 +545,6 @@ AdvSceneSwitcher.action.random="Zufall"
 AdvSceneSwitcher.action.random.allowRepeat="Aufeinanderfolgende Ausführung desselben Makros zulassen"
 AdvSceneSwitcher.action.random.entry="Zufällige Ausführung eines der folgenden Makros (pausierte Makros werden ignoriert)"
 AdvSceneSwitcher.action.systray="Benachrichtigung im System-Tray"
-AdvSceneSwitcher.action.systray.entry="Benachrichtigung anzeigen: {{message}}"
 AdvSceneSwitcher.action.screenshot="Screenshot"
 AdvSceneSwitcher.action.screenshot.save.default="Standard"
 AdvSceneSwitcher.action.screenshot.save.custom="Benutzerdefiniert"

data/locale/en-US.ini

@@ -107,6 +107,9 @@ AdvSceneSwitcher.macroTab.currentDisableHotkeys="Register hotkeys to control the
 AdvSceneSwitcher.macroTab.currentRegisterDock="Register dock widget to control the pause state of selected macro or run it manually"
 AdvSceneSwitcher.macroTab.currentDockAddRunButton="Add button to run the macro"
 AdvSceneSwitcher.macroTab.currentDockAddPauseButton="Add button to pause or unpause the macro"
+AdvSceneSwitcher.macroTab.currentDockButtonText.run="Run button text:"
+AdvSceneSwitcher.macroTab.currentDockButtonText.pause="Pause button text:"
+AdvSceneSwitcher.macroTab.currentDockButtonText.unpause="Unpause button text:"
 
 AdvSceneSwitcher.macroDock.pause="Pause"
 AdvSceneSwitcher.macroDock.unpause="Unpause"
@@ -161,9 +164,14 @@ AdvSceneSwitcher.condition.scene.previousSceneTransitionBehaviour="During transi
 AdvSceneSwitcher.condition.scene.entry.line1="{{sceneType}}{{scenes}}{{pattern}}"
 AdvSceneSwitcher.condition.scene.entry.line2="{{useTransitionTargetScene}}"
 AdvSceneSwitcher.condition.window="Window"
-AdvSceneSwitcher.condition.window.entry.line1="{{windows}} exist and ..."
-AdvSceneSwitcher.condition.window.entry.line2="... is {{fullscreen}} fullscreen {{maximized}} maximized {{focused}} focused {{windowFocusChanged}} foreground window changed"
-AdvSceneSwitcher.condition.window.entry.line3="Current foreground window: {{focusWindow}}"
+AdvSceneSwitcher.condition.window.entry.window="{{checkTitle}}Window title matches{{windowRegex}}{{windows}}"
+AdvSceneSwitcher.condition.window.entry.fullscreen="{{fullscreen}}Window is fullscreen"
+AdvSceneSwitcher.condition.window.entry.maximized="{{maximized}}Window is maximized"
+AdvSceneSwitcher.condition.window.entry.focused="{{focused}}Window is focused"
+AdvSceneSwitcher.condition.window.entry.focusedChange="{{windowFocusChanged}}Focus window changed"
+AdvSceneSwitcher.condition.window.entry.text="{{checkText}}Window contains text{{textRegex}}{{windowText}}"
+AdvSceneSwitcher.condition.window.entry.text.note="This option might not work on every text being displayed in a window.\nIf that is the case, you can consider using the Video conditions OCR check instead."
+AdvSceneSwitcher.condition.window.entry.currentFocus="Current focus window:{{focusWindow}}"
 AdvSceneSwitcher.condition.file="File"
 AdvSceneSwitcher.condition.file.type.match="matches"
 AdvSceneSwitcher.condition.file.type.contentChange="content changed"
@@ -253,7 +261,8 @@ AdvSceneSwitcher.condition.stream.state.start="Stream running"
 AdvSceneSwitcher.condition.stream.state.stop="Stream stopped"
 AdvSceneSwitcher.condition.stream.state.starting="Stream starting"
 AdvSceneSwitcher.condition.stream.state.stopping="Stream stopping"
-AdvSceneSwitcher.condition.stream.entry="{{streamState}}"
+AdvSceneSwitcher.condition.stream.state.keyFrameInterval="Keyframe interval equals"
+AdvSceneSwitcher.condition.stream.entry="{{streamState}}{{keyFrameInterval}}"
 AdvSceneSwitcher.condition.record="Recording"
 AdvSceneSwitcher.condition.record.state.start="Recording running"
 AdvSceneSwitcher.condition.record.state.pause="Recording paused"
@@ -318,7 +327,7 @@ AdvSceneSwitcher.condition.filter.type.settings="Settings match"
 AdvSceneSwitcher.condition.filter.getSettings="Get current settings"
 AdvSceneSwitcher.condition.filter.entry.line1="On {{sources}} {{filters}} {{conditions}}"
 AdvSceneSwitcher.condition.filter.entry.line2="{{settings}}"
-AdvSceneSwitcher.condition.filter.entry.line3="{{regex}} {{getSettings}}"
+AdvSceneSwitcher.condition.filter.entry.line3="{{regex}}{{getSettings}}"
 AdvSceneSwitcher.condition.sceneOrder="Scene item order"
 AdvSceneSwitcher.condition.sceneOrder.type.above="Is above"
 AdvSceneSwitcher.condition.sceneOrder.type.below="Is below"
@@ -430,6 +439,13 @@ AdvSceneSwitcher.condition.variable.entry="{{variables}}{{conditions}}{{strValue
 AdvSceneSwitcher.condition.run="Run"
 AdvSceneSwitcher.condition.run.entry="Process exits before timeout of{{timeout}} seconds"
 AdvSceneSwitcher.condition.run.entry.exit="{{checkExitCode}}Check for exit code{{exitCode}}"
+AdvSceneSwitcher.condition.midi="MIDI"
+AdvSceneSwitcher.condition.midi.entry="Mesasge was received from {{device}} which matches:"
+AdvSceneSwitcher.condition.midi.entry.listen="Set MIDI message selection to messages incoming on selected device: {{listenButton}}"
+AdvSceneSwitcher.condition.display="Display"
+AdvSceneSwitcher.condition.display.type.displayName="Name of connected displays matches"
+AdvSceneSwitcher.condition.display.type.displayCount="Number of connected displays is"
+AdvSceneSwitcher.condition.display.entry="{{conditions}}{{displays}}{{regex}}{{displayCount}}"
 
 ; Macro Actions
 AdvSceneSwitcher.action.switchScene="Switch scene"
@@ -463,9 +479,11 @@ AdvSceneSwitcher.action.recording.type.start="Start recording"
 AdvSceneSwitcher.action.recording.type.pause="Pause recording"
 AdvSceneSwitcher.action.recording.type.unpause="Unpause recording"
 AdvSceneSwitcher.action.recording.type.split="Split recording file"
+AdvSceneSwitcher.action.recording.type.changeOutputFolder="Change output folder"
+AdvSceneSwitcher.action.recording.type.changeOutputFileFormat="Change filename formatting"
 AdvSceneSwitcher.action.recording.pause.hint="Note that depending on your recording settings you might not be able to pause recording"
 AdvSceneSwitcher.action.recording.split.hint="Make sure to enable automatic file splitting in the OBS settings first!"
-AdvSceneSwitcher.action.recording.entry="{{actions}}{{pauseHint}}{{splitHint}}"
+AdvSceneSwitcher.action.recording.entry="{{actions}}{{recordFolder}}{{recordFileFormat}}{{pauseHint}}{{splitHint}}"
 AdvSceneSwitcher.action.replay="Replay buffer"
 AdvSceneSwitcher.action.replay.saveWarn="Warning: Saving too frequently might result in the replay buffer not actually being saved!"
 AdvSceneSwitcher.action.replay.type.stop="Stop replay buffer"
@@ -475,7 +493,8 @@ AdvSceneSwitcher.action.replay.entry="{{actions}}"
 AdvSceneSwitcher.action.streaming="Streaming"
 AdvSceneSwitcher.action.streaming.type.stop="Stop streaming"
 AdvSceneSwitcher.action.streaming.type.start="Start streaming"
-AdvSceneSwitcher.action.streaming.entry="{{actions}}"
+AdvSceneSwitcher.action.streaming.type.keyFrameInterval="Set keyframe interval"
+AdvSceneSwitcher.action.streaming.entry="{{actions}}{{keyFrameInterval}}"
 AdvSceneSwitcher.action.run="Run"
 AdvSceneSwitcher.action.sceneVisibility="Scene item visibility"
 AdvSceneSwitcher.action.sceneVisibility.type.show="Show"
@@ -522,6 +541,8 @@ AdvSceneSwitcher.action.pluginState.type.stop="Stop the Advanced Scene Switcher
 AdvSceneSwitcher.action.pluginState.type.noMatch="Change the no-match behaviour:"
 AdvSceneSwitcher.action.pluginState.type.import="Import settings from"
 AdvSceneSwitcher.action.pluginState.importWarning="Note: Action will be ignored while settings window is opened."
+AdvSceneSwitcher.action.pluginState.type.terminate="Shut down OBS"
+AdvSceneSwitcher.action.pluginState.terminateConfirm="OBS will be shut down automatically in 10 seconds!\nDo you want to continue shutting down OBS?"
 AdvSceneSwitcher.action.pluginState.entry="{{actions}}{{values}}{{scenes}}{{settings}}{{settingsWarning}}"
 AdvSceneSwitcher.action.virtualCamera="Virtual camera"
 AdvSceneSwitcher.action.virtualCamera.type.stop="Stop virtual camera"
@@ -577,7 +598,10 @@ AdvSceneSwitcher.action.random="Random"
 AdvSceneSwitcher.action.random.allowRepeat="Allow consecutive execution of the same macro"
 AdvSceneSwitcher.action.random.entry="Randomly run any of the following macros (paused macros are ignored)"
 AdvSceneSwitcher.action.systray="System tray notification"
-AdvSceneSwitcher.action.systray.entry="Show notification: {{message}}"
+AdvSceneSwitcher.action.systray.title="Title:"
+AdvSceneSwitcher.action.systray.message="Message:"
+AdvSceneSwitcher.action.systray.icon="Icon:"
+AdvSceneSwitcher.action.systray.iconHint="Leave blank to use the default icon"
 AdvSceneSwitcher.action.screenshot="Screenshot"
 AdvSceneSwitcher.action.screenshot.save.default="Default"
 AdvSceneSwitcher.action.screenshot.save.custom="Custom"
@@ -646,7 +670,10 @@ AdvSceneSwitcher.action.projector.windowed="Windowed"
 AdvSceneSwitcher.action.projector.fullscreen="Fullscreen"
 AdvSceneSwitcher.action.projector.entry="Open{{windowTypes}}projector of{{types}}{{scenes}}{{sources}}"
 AdvSceneSwitcher.action.projector.entry.monitor="on{{monitors}}"
-
+AdvSceneSwitcher.action.midi="MIDI"
+AdvSceneSwitcher.action.midi.entry="Send message to {{device}}:"
+AdvSceneSwitcher.action.midi.entry.listen="Set MIDI message selection to messages incoming on {{listenDevices}}: {{listenButton}}"
+AdvSceneSwitcher.action.osc="Open Sound Control"
 
 ; Transition Tab
 AdvSceneSwitcher.transitionTab.title="Transition"
@@ -926,6 +953,7 @@ AdvSceneSwitcher.connection.password="Password:"
 AdvSceneSwitcher.connection.reconnect="Reconnect automatically:"
 AdvSceneSwitcher.connection.reconnectDelay="Automatically reconnect after:"
 AdvSceneSwitcher.connection.connectOnStart="Connect on startup:"
+AdvSceneSwitcher.connection.useOBSWebsocketProtocol="<html><head/><body><p>Use the obs-websocket <a href=\"https://github.com/obsproject/obs-websocket/blob/master/docs/generated/protocol.md\"><span style=\" text-decoration: underline; color:#268bd2;\">protocol</span></a></p></body></html>"
 AdvSceneSwitcher.connection.test="Test connection"
 AdvSceneSwitcher.connection.status.disconnected="Disconnected"
 AdvSceneSwitcher.connection.status.connecting="Connecting"
@@ -948,6 +976,59 @@ AdvSceneSwitcher.process.entry.workingDirectory="Working directory:{{workingDire
 
 AdvSceneSwitcher.math.expressionFail="Failed evaluate expression"
 
+AdvSceneSwitcher.midi.deviceNamePattern="[Port #%1] %2"
+AdvSceneSwitcher.midi.message.type="Type:"
+AdvSceneSwitcher.midi.message.type.optional="Any"
+AdvSceneSwitcher.midi.message.type.invalid="Invalid"
+AdvSceneSwitcher.midi.message.type.noteOff="Note Off"
+AdvSceneSwitcher.midi.message.type.noteOn="Note On"
+AdvSceneSwitcher.midi.message.type.polyphonicPressure="Polyphonic Pressure"
+AdvSceneSwitcher.midi.message.type.controlChange="Control Change"
+AdvSceneSwitcher.midi.message.type.programChange="Program Change"
+AdvSceneSwitcher.midi.message.type.channelAftertouch="Channel Aftertouch"
+AdvSceneSwitcher.midi.message.type.pitchBend="Pitch Bend"
+AdvSceneSwitcher.midi.message.type.systemExclusive="System Exclusive"
+AdvSceneSwitcher.midi.message.type.timeCode="Time Code"
+AdvSceneSwitcher.midi.message.type.songPositionPointer="Song Position Pointer"
+AdvSceneSwitcher.midi.message.type.songSelect="Song Select"
+AdvSceneSwitcher.midi.message.type.reserved1="Reserved (1)"
+AdvSceneSwitcher.midi.message.type.reserved2="Reserved (2)"
+AdvSceneSwitcher.midi.message.type.tuneRequest="Tune Request"
+AdvSceneSwitcher.midi.message.type.endOfSystemExclusive="End of System Exclusive"
+AdvSceneSwitcher.midi.message.type.timeClock="Time Clock"
+AdvSceneSwitcher.midi.message.type.reserved3="Reserved (3)"
+AdvSceneSwitcher.midi.message.type.startFile="Start File"
+AdvSceneSwitcher.midi.message.type.continueFile="Continue File"
+AdvSceneSwitcher.midi.message.type.stopFile="Stop File"
+AdvSceneSwitcher.midi.message.type.reserved4="Reserved (4)"
+AdvSceneSwitcher.midi.message.type.activeSensing="Active Sensing"
+AdvSceneSwitcher.midi.message.type.systemReset="System Reset"
+AdvSceneSwitcher.midi.message.type.unknown="Unknown"
+AdvSceneSwitcher.midi.message.channel="Channel:"
+AdvSceneSwitcher.midi.message.note="Note / Value(1):"
+AdvSceneSwitcher.midi.message.value="Value(2):"
+AdvSceneSwitcher.midi.message.placeholder="Any"
+AdvSceneSwitcher.midi.resetDevices="Reconnect all MIDI devices"
+AdvSceneSwitcher.midi.startListen="Start listening"
+AdvSceneSwitcher.midi.stopListen="Stop listening"
+AdvSceneSwitcher.midi.startListenFail="Device is busy!\nSomething else is already listening!"
+AdvSceneSwitcher.midi.deviceOpenFail="Failed to initialize MIDI device!"
+
+AdvSceneSwitcher.osc.network="Network"
+AdvSceneSwitcher.osc.network.protocol="Protocol:"
+AdvSceneSwitcher.osc.network.address="Address:"
+AdvSceneSwitcher.osc.network.port="Port:"
+AdvSceneSwitcher.osc.message="Message"
+AdvSceneSwitcher.osc.message.type.none="None"
+AdvSceneSwitcher.osc.message.type.float="Float"
+AdvSceneSwitcher.osc.message.type.int="Integer"
+AdvSceneSwitcher.osc.message.type.string="String"
+AdvSceneSwitcher.osc.message.type.binaryBlob="Binary blob"
+AdvSceneSwitcher.osc.message.type.true="True"
+AdvSceneSwitcher.osc.message.type.false="False"
+AdvSceneSwitcher.osc.message.type.infinity="Infinitum"
+AdvSceneSwitcher.osc.message.type.null="Nil"
+
 AdvSceneSwitcher.selectScene="--select scene--"
 AdvSceneSwitcher.selectPreviousScene="Previous Scene"
 AdvSceneSwitcher.selectCurrentScene="Current Scene"

data/locale/es-ES.ini

@@ -179,7 +179,7 @@ AdvSceneSwitcher.condition.stream.state.start="Transmisión en ejecución"
 AdvSceneSwitcher.condition.stream.state.stop="Transmisión detenida"
 AdvSceneSwitcher.condition.stream.state.starting="Inicio de transmisión"
 AdvSceneSwitcher.condition.stream.state.stopping="Detener transmisión"
-AdvSceneSwitcher.condition.stream.entry="{{streamState}}"
+AdvSceneSwitcher.condition.stream.entry="{{streamState}}{{keyFrameInterval}}"
 AdvSceneSwitcher.condition.record="Grabación"
 AdvSceneSwitcher.condition.record.state.start="Grabación en ejecución"
 AdvSceneSwitcher.condition.record.state.pause="Grabación en pausa"
@@ -350,7 +350,7 @@ AdvSceneSwitcher.action.recording.type.start="Iniciar grabación"
 AdvSceneSwitcher.action.recording.type.pause="Pausar grabación"
 AdvSceneSwitcher.action.recording.type.unpause="Reanudar grabación"
 AdvSceneSwitcher.action.recording.pause.hint="Tenga en cuenta que, dependiendo de la configuración de grabación, es posible que no pueda pausar la grabación"
-AdvSceneSwitcher.action.recording.entry="{{actions}}{{pauseHint}}{{splitHint}}"
+AdvSceneSwitcher.action.recording.entry="{{actions}}{{recordFolder}}{{recordFileFormat}}{{pauseHint}}{{splitHint}}"
 AdvSceneSwitcher.action.replay="Búfer de reproducción"
 AdvSceneSwitcher.action.replay.saveWarn="Advertencia: ¡Guardar con demasiada frecuencia puede hacer que el búfer de reproducción no se guarde realmente!"
 AdvSceneSwitcher.action.replay.type.stop="Detener el búfer de reproducción"
@@ -360,7 +360,7 @@ AdvSceneSwitcher.action.replay.entry="{{actions}}"
 AdvSceneSwitcher.action.streaming="Transmisión"
 AdvSceneSwitcher.action.streaming.type.stop="Detener transmisión"
 AdvSceneSwitcher.action.streaming.type.start="Iniciar transmisión"
-AdvSceneSwitcher.action.streaming.entry="{{actions}}"
+AdvSceneSwitcher.action.streaming.entry="{{actions}}{{keyFrameInterval}}"
 AdvSceneSwitcher.action.run="Ejecutar"
 AdvSceneSwitcher.action.run.arguments="Argumentos:"
 AdvSceneSwitcher.action.run.addArgument="Agregar argumento"
@@ -460,7 +460,6 @@ AdvSceneSwitcher.action.timer.entry="{{timerAction}} temporizadores en {{macros}
 AdvSceneSwitcher.action.random="Aleatorio"
 AdvSceneSwitcher.action.random.entry="Ejecute aleatoriamente cualquiera de las siguientes macros (las macros en pausa se ignoran)"
 AdvSceneSwitcher.action.systray="Notificación de la bandeja del sistema"
-AdvSceneSwitcher.action.systray.entry="Mostrar notificación: {{message}}"
 AdvSceneSwitcher.action.screenshot="Captura de pantalla"
 AdvSceneSwitcher.action.screenshot.mainOutput="Salida principal de OBS"
 AdvSceneSwitcher.action.profile="Perfil"

data/locale/ru-RU.ini

@@ -135,7 +135,7 @@ AdvSceneSwitcher.action.recording.type.start="Начать запись"
 AdvSceneSwitcher.action.recording.type.pause="Пауза записи"
 AdvSceneSwitcher.action.recording.type.unpause="Снять запись с паузы"
 AdvSceneSwitcher.action.recording.pause.hint="Обратите внимание, что в зависимости от настроек записи вы можете не иметь возможности приостановить запись"
-AdvSceneSwitcher.action.recording.entry="{{actions}}{{pauseHint}}{{splitHint}}"
+AdvSceneSwitcher.action.recording.entry="{{actions}}{{recordFolder}}{{recordFileFormat}}{{pauseHint}}{{splitHint}}"
 AdvSceneSwitcher.action.replay="Буфер воспроизведения"
 AdvSceneSwitcher.action.replay.type.stop="Остановить буфер воспроизведения"
 AdvSceneSwitcher.action.replay.type.start="Начать воспроизведение буфера"
@@ -144,7 +144,7 @@ AdvSceneSwitcher.action.replay.entry="{{actions}}"
 AdvSceneSwitcher.action.streaming="Потоковое вещание"
 AdvSceneSwitcher.action.streaming.type.stop="Остановить потоковое вещание"
 AdvSceneSwitcher.action.streaming.type.start="Начать потоковое вещание"
-AdvSceneSwitcher.action.streaming.entry="{{actions}}"
+AdvSceneSwitcher.action.streaming.entry="{{actions}}{{keyFrameInterval}}"
 AdvSceneSwitcher.action.run="Запустить"
 
 

data/locale/tr-TR.ini

@@ -156,7 +156,7 @@ AdvSceneSwitcher.condition.stream.state.start="Yayın çalışıyor"
 AdvSceneSwitcher.condition.stream.state.stop="Yayın durdu"
 AdvSceneSwitcher.condition.stream.state.starting="Yayın başlıyor"
 AdvSceneSwitcher.condition.stream.state.stopping="Yayın duruyor"
-AdvSceneSwitcher.condition.stream.entry="{{streamState}}"
+AdvSceneSwitcher.condition.stream.entry="{{streamState}}{{keyFrameInterval}}"
 AdvSceneSwitcher.condition.record="Kayıt"
 AdvSceneSwitcher.condition.record.state.start="Kayıt Çalışıyor"
 AdvSceneSwitcher.condition.record.state.pause="Kayıt durakladı"
@@ -281,7 +281,7 @@ AdvSceneSwitcher.action.recording.type.start="Kayıt Başlat"
 AdvSceneSwitcher.action.recording.type.pause="Kayıt Duraklat"
 AdvSceneSwitcher.action.recording.type.unpause="Kayıt Duraklatma"
 AdvSceneSwitcher.action.recording.pause.hint="Kayıt ayarlarınıza bağlı olarak kaydı duraklatamayabileceğinizi unutmayın."
-AdvSceneSwitcher.action.recording.entry="{{actions}}{{pauseHint}}{{splitHint}}"
+AdvSceneSwitcher.action.recording.entry="{{actions}}{{recordFolder}}{{recordFileFormat}}{{pauseHint}}{{splitHint}}"
 AdvSceneSwitcher.action.replay="Tekrar arabelleği"
 AdvSceneSwitcher.action.replay.type.stop="Tekrar arabelleğini durdur"
 AdvSceneSwitcher.action.replay.type.start="Tekrar arabelleğini başlat"
@@ -290,7 +290,7 @@ AdvSceneSwitcher.action.replay.entry="{{actions}}"
 AdvSceneSwitcher.action.streaming="Yayın"
 AdvSceneSwitcher.action.streaming.type.stop="Yayın durdur"
 AdvSceneSwitcher.action.streaming.type.start="Yayın başlat"
-AdvSceneSwitcher.action.streaming.entry="{{actions}}"
+AdvSceneSwitcher.action.streaming.entry="{{actions}}{{keyFrameInterval}}"
 AdvSceneSwitcher.action.run="Çalıştır"
 AdvSceneSwitcher.action.run.arguments="Argümanlar:"
 AdvSceneSwitcher.action.run.addArgument="Argüman ekle"
@@ -377,7 +377,6 @@ AdvSceneSwitcher.action.timer.entry="{{timerAction}} zamanlayıcılar açık {{m
 AdvSceneSwitcher.action.random="Rastgele"
 AdvSceneSwitcher.action.random.entry="Aşağıdaki makrolardan herhangi birini rastgele çalıştırın (duraklatılmış makrolar yoksayılır)"
 AdvSceneSwitcher.action.systray="Sistem tepsisi bildirimi"
-AdvSceneSwitcher.action.systray.entry="Bildirimleri göster: {{message}}"
 AdvSceneSwitcher.action.screenshot="Ekran görüntüsü"
 AdvSceneSwitcher.action.screenshot.mainOutput="OBS'nin ana çıkışı"
 AdvSceneSwitcher.action.profile="Profil"

data/locale/zh-CN.ini

@@ -197,7 +197,7 @@ AdvSceneSwitcher.condition.stream.state.start="推流启动"
 AdvSceneSwitcher.condition.stream.state.stop="推流停止"
 AdvSceneSwitcher.condition.stream.state.starting="推流启动中"
 AdvSceneSwitcher.condition.stream.state.stopping="推流停止中"
-AdvSceneSwitcher.condition.stream.entry="{{streamState}}"
+AdvSceneSwitcher.condition.stream.entry="{{streamState}}{{keyFrameInterval}}"
 AdvSceneSwitcher.condition.record="录制"
 AdvSceneSwitcher.condition.record.state.start="录制运行中"
 AdvSceneSwitcher.condition.record.state.pause="录制暂停"
@@ -393,7 +393,7 @@ AdvSceneSwitcher.action.recording.type.unpause="取消录制暂停"
 AdvSceneSwitcher.action.recording.type.split="分割录制文件"
 AdvSceneSwitcher.action.recording.pause.hint="请注意，根据您的录制设置，您可能无法暂停录制"
 AdvSceneSwitcher.action.recording.split.hint="确保先在OBS设置中启用自动分割文件!"
-AdvSceneSwitcher.action.recording.entry="{{actions}}{{pauseHint}}{{splitHint}}"
+AdvSceneSwitcher.action.recording.entry="{{actions}}{{recordFolder}}{{recordFileFormat}}{{pauseHint}}{{splitHint}}"
 AdvSceneSwitcher.action.replay="回放缓冲区"
 AdvSceneSwitcher.action.replay.saveWarn="警告：保存过于频繁可能会导致重播缓冲区实际上未保存!"
 AdvSceneSwitcher.action.replay.type.stop="停止回放缓冲区"
@@ -403,7 +403,7 @@ AdvSceneSwitcher.action.replay.entry="{{actions}}"
 AdvSceneSwitcher.action.streaming="推流"
 AdvSceneSwitcher.action.streaming.type.stop="停止推流"
 AdvSceneSwitcher.action.streaming.type.start="开始推流"
-AdvSceneSwitcher.action.streaming.entry="{{actions}}"
+AdvSceneSwitcher.action.streaming.entry="{{actions}}{{keyFrameInterval}}"
 AdvSceneSwitcher.action.run="运行"
 AdvSceneSwitcher.action.run.arguments="参数:"
 AdvSceneSwitcher.action.run.addArgument="添加参数"
@@ -505,7 +505,6 @@ AdvSceneSwitcher.action.timer.entry="{{timerAction}} 定时在 {{macros}} {{dura
 AdvSceneSwitcher.action.random="随机"
 AdvSceneSwitcher.action.random.entry="随机运行以下任何宏（忽略暂停的宏）"
 AdvSceneSwitcher.action.systray="系统托盘通知"
-AdvSceneSwitcher.action.systray.entry="显示通知: {{message}}"
 AdvSceneSwitcher.action.screenshot="截图"
 AdvSceneSwitcher.action.screenshot.save.default="默认"
 AdvSceneSwitcher.action.screenshot.save.custom="其他"

data/res/images/DarkNote.svg

@@ -0,0 +1,24 @@
+<?xml version="1.0"?>
+<svg width="640" height="640" xmlns="http://www.w3.org/2000/svg" xmlns:svg="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" preserveAspectRatio="xMidYMid meet" version="1.1">
+ <defs>
+  <path d="m599.62,325.49c0,151.77 -123.21,274.98 -274.98,274.98c-151.76,0 -274.97,-123.21 -274.97,-274.98c0,-151.76 123.21,-274.97 274.97,-274.97c151.77,0 274.98,123.21 274.98,274.97z" id="c3Wyq0kfYS"/>
+  <mask height="689.95" id="maskanTyyngos" maskUnits="userSpaceOnUse" width="689.95" x="-20.33" y="-19.48">
+   <rect fill="white" height="689.95" id="svg_1" width="689.95" x="-20.33" y="-19.48"/>
+   <use fill="black" id="svg_2" xlink:href="#c3Wyq0kfYS"/>
+  </mask>
+  <path d="m334.97,96.07c4.54,0 8.23,3.68 8.23,8.23c0,46.94 0,179.54 0,226.48c0,4.54 -3.69,8.22 -8.23,8.22c-5.77,0 -14.88,0 -20.66,0c-4.54,0 -8.22,-3.68 -8.22,-8.22c0,-46.94 0,-179.54 0,-226.48c0,-4.55 3.68,-8.23 8.22,-8.23c5.78,0 14.89,0 20.66,0z" id="fxMeu932c"/>
+  <path d="m471.96,338.21c0.01,3.1 -2.5,5.62 -5.59,5.63c-32.02,0.09 -122.45,0.37 -154.46,0.47c-3.1,0.01 -5.61,-2.49 -5.62,-5.59c-0.02,-6.3 -0.06,-19.59 -0.08,-25.89c-0.01,-3.1 2.49,-5.62 5.59,-5.63c32.01,-0.09 122.44,-0.37 154.45,-0.47c3.1,-0.01 5.62,2.5 5.63,5.59c0.02,6.3 0.06,19.59 0.08,25.89z" id="h65nGmP2BL"/>
+ </defs>
+ <g class="layer">
+  <title>Layer 1</title>
+  <path fill="none" fill-opacity="null" id="svg_11" stroke="#000000" stroke-dasharray="null" stroke-linecap="null" stroke-linejoin="null" stroke-opacity="0.02"/>
+  <ellipse cx="103.84" cy="562.04" fill="#fefefe" id="svg_3" rx="80" ry="45" stroke="#000000" stroke-dasharray="null" stroke-linecap="null" stroke-linejoin="null" stroke-opacity="0.02" transform="rotate(-18.699, 103.843, 562.038)"/>
+  <ellipse cx="506" cy="554" fill="#fefefe" id="svg_4" rx="77" ry="45" stroke="#000000" stroke-dasharray="null" stroke-linecap="null" stroke-linejoin="null" stroke-opacity="0.02" transform="rotate(-18.699, 506, 554)"/>
+  <rect fill="#fefefe" height="359" id="svg_7" stroke="#000000" stroke-dasharray="null" stroke-linecap="null" stroke-linejoin="null" stroke-opacity="0.02" stroke-width="0" width="58" x="122" y="185"/>
+  <rect fill="#fefefe" height="453" id="svg_8" stroke="#000000" stroke-dasharray="null" stroke-linecap="null" stroke-linejoin="null" stroke-opacity="0.02" width="58" x="522" y="84.5"/>
+  <rect fill="#fefefe" height="37" id="svg_9" stroke="#000000" stroke-dasharray="null" stroke-linecap="null" stroke-linejoin="null" stroke-opacity="0.02" transform="rotate(-14.1985, 351.556, 146.245)" width="463.07" x="120.02" y="127.74"/>
+  <rect fill="none" fill-opacity="null" height="0" id="svg_10" stroke="#000000" stroke-dasharray="null" stroke-linecap="null" stroke-linejoin="null" stroke-opacity="0.02" width="0" x="538.25" y="107.12"/>
+  <path d="m537.42,112.06l0,-67.88l17.58,67.88z" fill="#fefefe" id="svg_16" stroke="#000000" stroke-dasharray="null" stroke-linecap="null" stroke-linejoin="null" stroke-opacity="0.02" transform="rotate(-90, 546.203, 78.1248)"/>
+  <rect fill="#fefefe" height="0" id="svg_18" stroke="#000000" stroke-dasharray="null" stroke-linecap="null" stroke-linejoin="null" stroke-opacity="0.02" width="0" x="82.12" y="287.56"/>
+ </g>
+</svg>

data/res/images/DarkRegex.svg

@@ -0,0 +1,10 @@
+<?xml version="1.0"?>
+<svg width="16" height="16" xmlns="http://www.w3.org/2000/svg" xmlns:svg="http://www.w3.org/2000/svg" preserveAspectRatio="xMidYMid meet" version="1.1">
+ <!-- Created with SVG-edit - https://github.com/SVG-Edit/svgedit-->
+
+ <g class="layer">
+  <title>Layer 1</title>
+  <text fill="#fefefe" font-family="Serif" font-size="24" id="svg_1" stroke="#fefefe" stroke-dasharray="null" stroke-linecap="null" stroke-linejoin="null" stroke-opacity="null" stroke-width="0" text-anchor="middle" transform="matrix(1.0974, 0, 0, 1.0974, -4.98544, 4.97639)" x="14" xml:space="preserve" y="13">*</text>
+  <rect fill="#fefefe" height="3.3" id="svg_2" stroke="#fefefe" stroke-dasharray="null" stroke-linecap="null" stroke-linejoin="null" transform="matrix(1, 0, 0, 1, 0, 0)" width="5" x="1" y="12"/>
+ </g>
+</svg>

data/res/images/LightNote.svg

@@ -0,0 +1,24 @@
+<?xml version="1.0"?>
+<svg width="640" height="640" xmlns="http://www.w3.org/2000/svg" xmlns:svg="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" preserveAspectRatio="xMidYMid meet" version="1.1">
+ <defs>
+  <path d="m599.62,325.49c0,151.77 -123.21,274.98 -274.98,274.98c-151.76,0 -274.97,-123.21 -274.97,-274.98c0,-151.76 123.21,-274.97 274.97,-274.97c151.77,0 274.98,123.21 274.98,274.97z" id="c3Wyq0kfYS"/>
+  <mask height="689.95" id="maskanTyyngos" maskUnits="userSpaceOnUse" width="689.95" x="-20.33" y="-19.48">
+   <rect fill="white" height="689.95" id="svg_1" width="689.95" x="-20.33" y="-19.48"/>
+   <use fill="black" id="svg_2" xlink:href="#c3Wyq0kfYS"/>
+  </mask>
+  <path d="m334.97,96.07c4.54,0 8.23,3.68 8.23,8.23c0,46.94 0,179.54 0,226.48c0,4.54 -3.69,8.22 -8.23,8.22c-5.77,0 -14.88,0 -20.66,0c-4.54,0 -8.22,-3.68 -8.22,-8.22c0,-46.94 0,-179.54 0,-226.48c0,-4.55 3.68,-8.23 8.22,-8.23c5.78,0 14.89,0 20.66,0z" id="fxMeu932c"/>
+  <path d="m471.96,338.21c0.01,3.1 -2.5,5.62 -5.59,5.63c-32.02,0.09 -122.45,0.37 -154.46,0.47c-3.1,0.01 -5.61,-2.49 -5.62,-5.59c-0.02,-6.3 -0.06,-19.59 -0.08,-25.89c-0.01,-3.1 2.49,-5.62 5.59,-5.63c32.01,-0.09 122.44,-0.37 154.45,-0.47c3.1,-0.01 5.62,2.5 5.63,5.59c0.02,6.3 0.06,19.59 0.08,25.89z" id="h65nGmP2BL"/>
+ </defs>
+ <g class="layer">
+  <title>Layer 1</title>
+  <path fill="none" fill-opacity="null" id="svg_11" stroke="#000000" stroke-dasharray="null" stroke-linecap="null" stroke-linejoin="null" stroke-opacity="0.02"/>
+  <ellipse cx="103.84" cy="562.04" fill="#202020" id="svg_3" rx="80" ry="45" stroke="#000000" stroke-dasharray="null" stroke-linecap="null" stroke-linejoin="null" stroke-opacity="0.02" transform="rotate(-18.699, 103.843, 562.038)"/>
+  <ellipse cx="506" cy="554" fill="#202020" id="svg_4" rx="77" ry="45" stroke="#000000" stroke-dasharray="null" stroke-linecap="null" stroke-linejoin="null" stroke-opacity="0.02" transform="rotate(-18.699, 506, 554)"/>
+  <rect fill="#202020" height="359" id="svg_7" stroke="#000000" stroke-dasharray="null" stroke-linecap="null" stroke-linejoin="null" stroke-opacity="0.02" stroke-width="0" width="58" x="122" y="185"/>
+  <rect fill="#202020" height="453" id="svg_8" stroke="#000000" stroke-dasharray="null" stroke-linecap="null" stroke-linejoin="null" stroke-opacity="0.02" width="58" x="522" y="84.5"/>
+  <rect fill="#202020" height="37" id="svg_9" stroke="#000000" stroke-dasharray="null" stroke-linecap="null" stroke-linejoin="null" stroke-opacity="0.02" transform="rotate(-14.1985, 351.556, 146.245)" width="463.07" x="120.02" y="127.74"/>
+  <rect fill="none" fill-opacity="null" height="0" id="svg_10" stroke="#000000" stroke-dasharray="null" stroke-linecap="null" stroke-linejoin="null" stroke-opacity="0.02" width="0" x="538.25" y="107.12"/>
+  <path d="m537.42,112.06l0,-67.88l17.58,67.88z" fill="#202020" id="svg_16" stroke="#000000" stroke-dasharray="null" stroke-linecap="null" stroke-linejoin="null" stroke-opacity="0.02" transform="rotate(-90, 546.203, 78.1248)"/>
+  <rect fill="#202020" height="0" id="svg_18" stroke="#000000" stroke-dasharray="null" stroke-linecap="null" stroke-linejoin="null" stroke-opacity="0.02" width="0" x="82.12" y="287.56"/>
+ </g>
+</svg>

data/res/images/LightRegex.svg

@@ -0,0 +1,10 @@
+<?xml version="1.0"?>
+<svg width="16" height="16" xmlns="http://www.w3.org/2000/svg" xmlns:svg="http://www.w3.org/2000/svg" preserveAspectRatio="xMidYMid meet" version="1.1">
+ <!-- Created with SVG-edit - https://github.com/SVG-Edit/svgedit-->
+
+ <g class="layer">
+  <title>Layer 1</title>
+  <text fill="#202020" font-family="Serif" font-size="24" id="svg_1" stroke="#000000" stroke-dasharray="null" stroke-linecap="null" stroke-linejoin="null" stroke-opacity="null" stroke-width="0" text-anchor="middle" transform="matrix(1.0974, 0, 0, 1.0974, -4.98544, 4.97639)" x="14" xml:space="preserve" y="13">*</text>
+  <rect fill="#202020" height="3.3" id="svg_2" stroke="#202020" stroke-dasharray="null" stroke-linecap="null" stroke-linejoin="null" transform="matrix(1, 0, 0, 1, 0, 0)" width="5" x="1" y="12"/>
+ </g>
+</svg>

forms/advanced-scene-switcher.ui

@@ -658,7 +658,7 @@
             </widget>
            </item>
            <item>
-            <widget class="MacroTree" name="macros">
+            <widget class="advss::MacroTree" name="macros">
              <property name="showDropIndicator" stdset="0">
               <bool>true</bool>
              </property>
@@ -4563,7 +4563,7 @@
  </widget>
  <customwidgets>
   <customwidget>
-   <class>MacroTree</class>
+   <class>advss::MacroTree</class>
    <extends>QListView</extends>
    <header>macro-tree.hpp</header>
   </customwidget>

src/advanced-scene-switcher.cpp

@@ -9,29 +9,15 @@
 #include <obs-frontend-api.h>
 
 #include "advanced-scene-switcher.hpp"
+#include "switcher-data.hpp"
 #include "status-control.hpp"
+#include "scene-switch-helpers.hpp"
 #include "curl-helper.hpp"
+#include "platform-funcs.hpp"
 #include "utility.hpp"
 #include "version.h"
 
-const char *obs_module_text(const char *text)
-{
-	if (!switcher) {
-		return "";
-	}
-	return switcher->translate(text);
-}
-
-obs_module_t *obs_current_module()
-{
-	return switcher->modulePtr;
-}
-
-SwitcherData *switcher = nullptr;
-SwitcherData *GetSwitcher()
-{
-	return switcher;
-}
+namespace advss {
 
 AdvSceneSwitcher *AdvSceneSwitcher::window = nullptr;
 
@@ -45,7 +31,7 @@ AdvSceneSwitcher::AdvSceneSwitcher(QWidget *parent)
 	ui->setupUi(this);
 	std::lock_guard<std::mutex> lock(switcher->m);
 	switcher->Prune();
-	loadUI();
+	LoadUI();
 }
 
 AdvSceneSwitcher::~AdvSceneSwitcher()
@@ -97,35 +83,35 @@ static void DisplayMissingDataDirWarning()
 	DisplayMessage(msg);
 }
 
-void AdvSceneSwitcher::loadUI()
+void AdvSceneSwitcher::LoadUI()
 {
 	DisplayMissingDataDirWarning();
 	DisplayMissingDependencyWarning();
 
-	setupGeneralTab();
-	setupTitleTab();
-	setupExecutableTab();
-	setupRegionTab();
-	setupPauseTab();
-	setupSequenceTab();
-	setupTransitionsTab();
-	setupIdleTab();
-	setupRandomTab();
-	setupMediaTab();
-	setupFileTab();
-	setupTimeTab();
-	setupAudioTab();
-	setupVideoTab();
-	setupNetworkTab();
-	setupSceneGroupTab();
-	setupTriggerTab();
-	setupMacroTab();
+	SetupGeneralTab();
+	SetupTitleTab();
+	SetupExecutableTab();
+	SetupRegionTab();
+	SetupPauseTab();
+	SetupSequenceTab();
+	SetupTransitionsTab();
+	SetupIdleTab();
+	SetupRandomTab();
+	SetupMediaTab();
+	SetupFileTab();
+	SetupTimeTab();
+	SetupAudioTab();
+	SetupVideoTab();
+	SetupNetworkTab();
+	SetupSceneGroupTab();
+	SetupTriggerTab();
+	SetupMacroTab();
 
-	setDeprecationWarnings();
-	setTabOrder();
-	setCurrentTab();
-	restoreWindowGeo();
-	checkFirstTimeSetup();
+	SetDeprecationWarnings();
+	SetTabOrder();
+	SetCurrentTab();
+	RestoreWindowGeo();
+	CheckFirstTimeSetup();
 
 	loading = false;
 }
@@ -133,13 +119,15 @@ void AdvSceneSwitcher::loadUI()
 /******************************************************************************
  * Saving and loading
  ******************************************************************************/
+static void AskForBackup(obs_data_t *obj);
+
 static void SaveSceneSwitcher(obs_data_t *save_data, bool saving, void *)
 {
 	if (saving) {
 		std::lock_guard<std::mutex> lock(switcher->m);
 		switcher->Prune();
 		obs_data_t *obj = obs_data_create();
-		switcher->saveSettings(obj);
+		switcher->SaveSettings(obj);
 		obs_data_set_obj(save_data, "advanced-scene-switcher", obj);
 		obs_data_release(obj);
 	} else {
@@ -153,10 +141,10 @@ static void SaveSceneSwitcher(obs_data_t *save_data, bool saving, void *)
 		if (!obj) {
 			obj = obs_data_create();
 		}
-		if (switcher->versionChanged(obj, g_GIT_SHA1)) {
+		if (switcher->VersionChanged(obj, g_GIT_SHA1)) {
 			AskForBackup(obj);
 		}
-		switcher->loadSettings(obj);
+		switcher->LoadSettings(obj);
 		obs_data_release(obj);
 		switcher->m.unlock();
 
@@ -166,6 +154,34 @@ static void SaveSceneSwitcher(obs_data_t *save_data, bool saving, void *)
 	}
 }
 
+static void AskForBackup(obs_data_t *obj)
+{
+	bool backupSettings = DisplayMessage(
+		obs_module_text("AdvSceneSwitcher.askBackup"), true);
+
+	if (!backupSettings) {
+		return;
+	}
+
+	QString path = QFileDialog::getSaveFileName(
+		nullptr,
+		obs_module_text(
+			"AdvSceneSwitcher.generalTab.saveOrLoadsettings.exportWindowTitle"),
+		GetDefaultSettingsSaveLocation(),
+		obs_module_text(
+			"AdvSceneSwitcher.generalTab.saveOrLoadsettings.textType"));
+	if (path.isEmpty()) {
+		return;
+	}
+
+	QFile file(path);
+	if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
+		return;
+	}
+
+	obs_data_save_json(obj, file.fileName().toUtf8().constData());
+}
+
 /******************************************************************************
  * Main switcher thread
  ******************************************************************************/
@@ -209,7 +225,7 @@ void SwitcherData::Thread()
 		}
 
 		vblog(LOG_INFO, "try to sleep for %ld", duration.count());
-		setWaitScene();
+		SetWaitScene();
 		cv.wait_for(lock, duration);
 
 		startTime = std::chrono::high_resolution_clock::now();
@@ -223,13 +239,13 @@ void SwitcherData::Thread()
 		if (checkPause()) {
 			continue;
 		}
-		setPreconditions();
-		match = checkForMatch(scene, transition, linger,
+		SetPreconditions();
+		match = CheckForMatch(scene, transition, linger,
 				      setPrevSceneAfterLinger, macroMatch);
 		if (stop) {
 			break;
 		}
-		checkNoMatchSwitch(match, scene, transition, sleep);
+		CheckNoMatchSwitch(match, scene, transition, sleep);
 		checkSwitchCooldown(match);
 
 		if (linger) {
@@ -237,14 +253,14 @@ void SwitcherData::Thread()
 			vblog(LOG_INFO, "sleep for %ld before switching scene",
 			      duration.count());
 
-			setWaitScene();
+			SetWaitScene();
 			cv.wait_for(lock, duration);
 
 			if (stop) {
 				break;
 			}
 
-			if (sceneChangedDuringWait()) {
+			if (SceneChangedDuringWait()) {
 				vblog(LOG_INFO,
 				      "scene was changed manually - ignoring match");
 
@@ -255,13 +271,13 @@ void SwitcherData::Thread()
 			}
 		}
 
-		ClearWebsocketMessages();
+		ResetForNextInterval();
 
 		if (match) {
 			if (macroMatch) {
-				runMacros();
+				RunMacros();
 			} else {
-				switchScene({scene, transition, 0});
+				SwitchScene({scene, transition, 0});
 			}
 		}
 
@@ -274,7 +290,7 @@ void SwitcherData::Thread()
 	blog(LOG_INFO, "stopped");
 }
 
-void SwitcherData::setPreconditions()
+void SwitcherData::SetPreconditions()
 {
 	// Window title
 	lastTitle = currentTitle;
@@ -302,13 +318,23 @@ void SwitcherData::setPreconditions()
 	GetForegroundProcessName(currentForegroundProcess);
 
 	// Cursor
-	std::pair<int, int> cursorPos = getCursorPos();
+	std::pair<int, int> cursorPos = GetCursorPos();
 	cursorPosChanged = cursorPos.first != switcher->lastCursorPos.first ||
 			   cursorPos.second != switcher->lastCursorPos.second;
-	lastCursorPos = getCursorPos();
+	lastCursorPos = GetCursorPos();
 }
 
-bool SwitcherData::checkForMatch(OBSWeakSource &scene,
+void SwitcherData::ResetForNextInterval()
+{
+	// Core reset functions
+	ClearWebsocketMessages();
+	// Plugin reset functions
+	for (const auto &func : resetForNextIntervalFuncs) {
+		func();
+	}
+}
+
+bool SwitcherData::CheckForMatch(OBSWeakSource &scene,
 				 OBSWeakSource &transition, int &linger,
 				 bool &setPrevSceneAfterLinger,
 				 bool &macroMatch)
@@ -358,7 +384,7 @@ bool SwitcherData::checkForMatch(OBSWeakSource &scene,
 			match = checkVideoSwitch(scene, transition);
 			break;
 		case macro_func:
-			if (checkMacros()) {
+			if (CheckMacros()) {
 				match = true;
 				macroMatch = true;
 			}
@@ -375,48 +401,20 @@ bool SwitcherData::checkForMatch(OBSWeakSource &scene,
 	return match;
 }
 
-void switchScene(const sceneSwitchInfo &sceneSwitch, bool force)
+static void ResetMacros()
 {
-	if (!sceneSwitch.scene && switcher->verbose) {
-		blog(LOG_INFO, "nothing to switch to");
-		return;
+	for (auto &m : switcher->macros) {
+		m->ResetRunCount();
+		m->ResetTimers();
 	}
-
-	obs_source_t *source = obs_weak_source_get_source(sceneSwitch.scene);
-	obs_source_t *currentSource = obs_frontend_get_current_scene();
-
-	if (source && (source != currentSource || force)) {
-		transitionData currentTransitionData;
-		setNextTransition(sceneSwitch, currentSource,
-				  currentTransitionData);
-		obs_frontend_set_current_scene(source);
-		if (switcher->transitionOverrideOverride) {
-			restoreTransitionOverride(source,
-						  currentTransitionData);
-		}
-
-		if (switcher->verbose) {
-			blog(LOG_INFO, "switched scene");
-		}
-
-		if (switcher->networkConfig.ShouldSendSceneChange()) {
-			switcher->server.sendMessage(sceneSwitch);
-		}
-	}
-	obs_source_release(currentSource);
-	obs_source_release(source);
-}
-
-void switchPreviewScene(const OBSWeakSource &ws)
-{
-	auto source = obs_weak_source_get_source(ws);
-	obs_frontend_set_current_preview_scene(source);
-	obs_source_release(source);
 }
 
 void SwitcherData::Start()
 {
 	if (!(th && th->isRunning())) {
+		ResetForNextInterval();
+		ResetMacros();
+
 		stop = false;
 		th = new SwitcherThread();
 		th->start((QThread::Priority)threadPriority);
@@ -441,14 +439,6 @@ void SwitcherData::Start()
 	}
 }
 
-void ResetMacros()
-{
-	for (auto &m : switcher->macros) {
-		m->ResetRunCount();
-		m->ResetTimers();
-	}
-}
-
 void SwitcherData::Stop()
 {
 	if (th && th->isRunning()) {
@@ -462,7 +452,6 @@ void SwitcherData::Stop()
 		th = nullptr;
 
 		writeToStatusFile("Advanced Scene Switcher stopped");
-		ResetMacros();
 	}
 
 	server.stop();
@@ -475,13 +464,13 @@ void SwitcherData::Stop()
 	}
 }
 
-void SwitcherData::setWaitScene()
+void SwitcherData::SetWaitScene()
 {
 	waitScene = obs_frontend_get_current_scene();
 	obs_source_release(waitScene);
 }
 
-bool SwitcherData::sceneChangedDuringWait()
+bool SwitcherData::SceneChangedDuringWait()
 {
 	obs_source_t *currentSource = obs_frontend_get_current_scene();
 	if (!currentSource) {
@@ -494,7 +483,7 @@ bool SwitcherData::sceneChangedDuringWait()
 // Relies on the fact that switcher->currentScene will only be updated on event
 // OBS_FRONTEND_EVENT_SCENE_CHANGED but obs_frontend_get_current_scene() will
 // already return the scene to be transitioned to.
-bool SwitcherData::anySceneTransitionStarted()
+bool SwitcherData::AnySceneTransitionStarted()
 {
 	auto currentSceneSrouce = obs_frontend_get_current_scene();
 	auto currentScene = obs_source_get_weak_source(currentSceneSrouce);
@@ -515,13 +504,13 @@ extern "C" void FreeSceneSwitcher()
 	switcher = nullptr;
 }
 
-void handleSceneChange()
+static void handleSceneChange()
 {
 	switcher->lastSceneChangeTime =
 		std::chrono::high_resolution_clock::now();
 
 	// Stop waiting if scene was changed
-	if (switcher->sceneChangedDuringWait()) {
+	if (switcher->SceneChangedDuringWait()) {
 		switcher->cv.notify_one();
 	}
 
@@ -549,31 +538,33 @@ void handleSceneChange()
 	}
 }
 
-void setLiveTime()
+static void setLiveTime()
 {
 	switcher->liveTime = QDateTime::currentDateTime();
 }
 
-void resetLiveTime()
+static void resetLiveTime()
 {
 	switcher->liveTime = QDateTime();
 }
 
-void checkAutoStartRecording()
+static void checkAutoStartRecording()
 {
-	if (switcher->autoStartEvent == AutoStartEvent::RECORDING ||
-	    switcher->autoStartEvent == AutoStartEvent::RECORINDG_OR_STREAMING)
+	if (switcher->autoStartEvent == SwitcherData::AutoStart::RECORDING ||
+	    switcher->autoStartEvent ==
+		    SwitcherData::AutoStart::RECORINDG_OR_STREAMING)
 		switcher->Start();
 }
 
-void checkAutoStartStreaming()
+static void checkAutoStartStreaming()
 {
-	if (switcher->autoStartEvent == AutoStartEvent::STREAMING ||
-	    switcher->autoStartEvent == AutoStartEvent::RECORINDG_OR_STREAMING)
+	if (switcher->autoStartEvent == SwitcherData::AutoStart::STREAMING ||
+	    switcher->autoStartEvent ==
+		    SwitcherData::AutoStart::RECORINDG_OR_STREAMING)
 		switcher->Start();
 }
 
-void handlePeviewSceneChange()
+static void handlePeviewSceneChange()
 {
 	if (switcher->networkConfig.ShouldSendPrviewSceneChange()) {
 		auto source = obs_frontend_get_current_preview_scene();
@@ -584,43 +575,45 @@ void handlePeviewSceneChange()
 	}
 }
 
-void setReplayBufferSaved()
+static void setReplayBufferSaved()
 {
 	switcher->replayBufferSaved = true;
 }
 
-void setTranstionEnd()
+static void setTranstionEnd()
 {
 	switcher->lastTransitionEndTime =
 		std::chrono::high_resolution_clock::now();
 	switcher->macroTransitionCv.notify_all();
 }
 
-void setStreamStarting()
+static void setStreamStarting()
 {
 	switcher->lastStreamStartingTime =
 		std::chrono::high_resolution_clock::now();
 }
 
-void setStreamStopping()
+static void setStreamStopping()
 {
 	switcher->lastStreamStoppingTime =
 		std::chrono::high_resolution_clock::now();
 }
 
-void handleExit()
+static void handleExit()
 {
+	if (!switcher) {
+		return;
+	}
 	switcher->obsIsShuttingDown = true;
-	if (switcher && switcher->obsIsShuttingDown &&
-	    switcher->shutdownConditionCount) {
+	if (switcher->shutdownConditionCount) {
 		switcher->Stop();
-		switcher->checkMacros();
-		switcher->runMacros();
+		switcher->CheckMacros();
+		switcher->RunMacros();
 	}
 	FreeSceneSwitcher();
 }
 
-void handleSceneCollectionChanging()
+static void handleSceneCollectionChanging()
 {
 	if (switcher->settingsWindowOpened) {
 		AdvSceneSwitcher::window->close();
@@ -686,7 +679,7 @@ static void OBSEvent(enum obs_frontend_event event, void *switcher)
 	}
 }
 
-void LoadPlugins()
+static void LoadPlugins()
 {
 	QFileInfo libPath(
 		QString(obs_get_module_binary_path(obs_current_module())));
@@ -730,14 +723,12 @@ void OpenSettingsWindow()
 	}
 }
 
-extern "C" void InitSceneSwitcher(obs_module_t *m, translateFunc t)
+extern "C" void InitSceneSwitcher(obs_module_t *module, translateFunc translate)
 {
 	blog(LOG_INFO, "version: %s", g_GIT_TAG);
 	blog(LOG_INFO, "version: %s", g_GIT_SHA1);
 
-	switcher = new SwitcherData;
-	switcher->modulePtr = m;
-	switcher->translate = t;
+	switcher = new SwitcherData(module, translate);
 
 	PlatformInit();
 	LoadPlugins();
@@ -750,3 +741,5 @@ extern "C" void InitSceneSwitcher(obs_module_t *m, translateFunc t)
 		obs_module_text("AdvSceneSwitcher.pluginName"));
 	action->connect(action, &QAction::triggered, OpenSettingsWindow);
 }
+
+} // namespace advss

src/advanced-scene-switcher.hpp

@@ -1,19 +1,18 @@
 #pragma once
-#include "switcher-data-structs.hpp"
-#include "platform-funcs.hpp"
+#include "macro-segment-list.hpp"
+#include "log-helper.hpp"
 
-#include <macro-segment-list.hpp>
 #include <ui_advanced-scene-switcher.h>
 
-#define blog(level, msg, ...) blog(level, "[adv-ss] " msg, ##__VA_ARGS__)
-#define vblog(level, msg, ...)                   \
-	if (switcher->verbose) {                 \
-		blog(level, msg, ##__VA_ARGS__); \
-	}
-
 class QCloseEvent;
+
+namespace advss {
+
 class MacroActionEdit;
 class MacroConditionEdit;
+class Duration;
+class SequenceWidget;
+struct SceneGroup;
 
 /*******************************************************************************
  * Advanced Scene Switcher window
@@ -33,82 +32,20 @@ public:
 	void reject() override;
 	void closeEvent(QCloseEvent *event) override;
 
-	void SetShowFrames();
-	void SetHideFrames();
-	void clearFrames(QListWidget *list);
+	void LoadUI();
 
-	int IgnoreWindowsFindByData(const QString &window);
-	int IgnoreIdleWindowsFindByData(const QString &window);
+	void SetTabOrder();
+	void SetCurrentTab();
+	void RestoreWindowGeo();
+	void CheckFirstTimeSetup();
 
+	/* --- Begin of general tab section --- */
+public:
+	void SetupGeneralTab();
 	void UpdateNonMatchingScene(const QString &name);
-	void OpenSequenceExtendEdit(SequenceWidget *sw);
-	void SetEditSceneGroup(SceneGroup &sg);
-
-	bool addNewMacro(std::shared_ptr<Macro> &res, std::string &name,
-			 std::string format = "");
-	void RemoveMacro(std::shared_ptr<Macro> &);
-	void RenameMacro(std::shared_ptr<Macro> &, const QString &name);
-	std::shared_ptr<Macro> getSelectedMacro();
-	std::vector<std::shared_ptr<Macro>> getSelectedMacros();
-	void SetEditMacro(Macro &m);
-	void SetMacroEditAreaDisabled(bool);
-	void HighlightAction(int idx, QColor color = QColor(Qt::green));
-	void HighlightCondition(int idx, QColor color = QColor(Qt::green));
-	void PopulateMacroActions(Macro &m, uint32_t afterIdx = 0);
-	void PopulateMacroConditions(Macro &m, uint32_t afterIdx = 0);
-	void SetActionData(Macro &m);
-	void SetConditionData(Macro &m);
-	void SwapActions(Macro *m, int pos1, int pos2);
-	void SwapConditions(Macro *m, int pos1, int pos2);
-
-	void loadUI();
-	void setupGeneralTab();
-	void setupTitleTab();
-	void setupExecutableTab();
-	void setupRegionTab();
-	void setupPauseTab();
-	void setupSequenceTab();
-	void setupTransitionsTab();
-	void setupIdleTab();
-	void setupRandomTab();
-	void setupMediaTab();
-	void setupFileTab();
-	void setupTimeTab();
-	void setupAudioTab();
-	void setupSceneGroupTab();
-	void setupTriggerTab();
-	void setupVideoTab();
-	void setupNetworkTab();
-	void setupMacroTab();
-	void setDeprecationWarnings();
-	void setTabOrder();
-	void setCurrentTab();
-	void restoreWindowGeo();
-	void checkFirstTimeSetup();
-
-signals:
-	void MacroAdded(const QString &name);
-	void MacroRemoved(const QString &name);
-	void MacroRenamed(const QString &oldName, const QString &newName);
-	void MacroSegmentOrderChanged();
-	void HighlightMacrosChanged(bool value);
-	void HighlightActionsChanged(bool value);
-	void HighlightConditionsChanged(bool value);
-	void SceneGroupAdded(const QString &name);
-	void SceneGroupRemoved(const QString &name);
-	void SceneGroupRenamed(const QString &oldName, const QString newName);
-	void ConnectionAdded(const QString &);
-	void ConnectionRenamed(const QString &oldName, const QString &newName);
-	void ConnectionRemoved(const QString &);
-	void VariableAdded(const QString &);
-	void VariableRenamed(const QString &oldName, const QString &newName);
-	void VariableRemoved(const QString &);
+	void SetDeprecationWarnings();
 
 public slots:
-	void on_windowUp_clicked();
-	void on_windowDown_clicked();
-	void on_windowAdd_clicked();
-	void on_windowRemove_clicked();
 	void on_noMatchDontSwitch_clicked();
 	void on_noMatchSwitch_clicked();
 	void on_noMatchRandomSwitch_clicked();
@@ -120,7 +57,41 @@ public slots:
 	void on_checkInterval_valueChanged(int value);
 	void on_tabMoved(int from, int to);
 	void on_tabWidget_currentChanged(int index);
+	void on_exportSettings_clicked();
+	void on_importSettings_clicked();
+	void on_verboseLogging_stateChanged(int state);
+	void on_saveWindowGeo_stateChanged(int state);
+	void on_showTrayNotifications_stateChanged(int state);
+	void on_uiHintsDisable_stateChanged(int state);
+	void on_warnPluginLoadFailure_stateChanged(int state);
+	void on_hideLegacyTabs_stateChanged(int state);
+	void on_priorityUp_clicked();
+	void on_priorityDown_clicked();
+	void on_threadPriority_currentTextChanged(const QString &text);
 
+	/* --- End of legacy tab section --- */
+
+	/* --- Begin of macro tab section --- */
+public:
+	void SetupMacroTab();
+	bool AddNewMacro(std::shared_ptr<Macro> &res, std::string &name,
+			 std::string format = "");
+	void RemoveMacro(std::shared_ptr<Macro> &);
+	void RenameMacro(std::shared_ptr<Macro> &, const QString &name);
+	std::shared_ptr<Macro> GetSelectedMacro();
+	std::vector<std::shared_ptr<Macro>> GetSelectedMacros();
+	void SetEditMacro(Macro &m);
+	void SetMacroEditAreaDisabled(bool);
+	void HighlightAction(int idx, QColor color = QColor(Qt::green));
+	void HighlightCondition(int idx, QColor color = QColor(Qt::green));
+	void PopulateMacroActions(Macro &m, uint32_t afterIdx = 0);
+	void PopulateMacroConditions(Macro &m, uint32_t afterIdx = 0);
+	void SetActionData(Macro &m);
+	void SetConditionData(Macro &m);
+	void SwapActions(Macro *m, int pos1, int pos2);
+	void SwapConditions(Macro *m, int pos1, int pos2);
+
+public slots:
 	void on_macroAdd_clicked();
 	void on_macroRemove_clicked();
 	void on_macroUp_clicked();
@@ -173,136 +144,21 @@ public slots:
 	void HighlightOnChange();
 	void on_macroProperties_clicked();
 
-	void on_screenRegionSwitches_currentRowChanged(int idx);
-	void on_showFrame_clicked();
-	void on_screenRegionAdd_clicked();
-	void on_screenRegionRemove_clicked();
-	void on_screenRegionUp_clicked();
-	void on_screenRegionDown_clicked();
+signals:
+	void MacroAdded(const QString &name);
+	void MacroRemoved(const QString &name);
+	void MacroRenamed(const QString &oldName, const QString &newName);
+	void MacroSegmentOrderChanged();
+	void HighlightMacrosChanged(bool value);
+	void HighlightActionsChanged(bool value);
+	void HighlightConditionsChanged(bool value);
 
-	void on_pauseUp_clicked();
-	void on_pauseDown_clicked();
-	void on_pauseAdd_clicked();
-	void on_pauseRemove_clicked();
-
-	void on_ignoreWindows_currentRowChanged(int idx);
-	void on_ignoreWindowsAdd_clicked();
-	void on_ignoreWindowsRemove_clicked();
-
-	void on_sceneSequenceAdd_clicked();
-	void on_sceneSequenceRemove_clicked();
-	void on_sceneSequenceUp_clicked();
-	void on_sceneSequenceDown_clicked();
-	void on_sceneSequenceSave_clicked();
-	void on_sceneSequenceLoad_clicked();
-	void on_sequenceEdit_clicked();
-	void on_sceneSequenceSwitches_itemDoubleClicked(QListWidgetItem *item);
-
-	void on_verboseLogging_stateChanged(int state);
-	void on_saveWindowGeo_stateChanged(int state);
-	void on_showTrayNotifications_stateChanged(int state);
-	void on_uiHintsDisable_stateChanged(int state);
-	void on_warnPluginLoadFailure_stateChanged(int state);
-	void on_hideLegacyTabs_stateChanged(int state);
-
-	void on_exportSettings_clicked();
-	void on_importSettings_clicked();
-
-	void on_transitionsAdd_clicked();
-	void on_transitionsRemove_clicked();
-	void on_transitionsUp_clicked();
-	void on_transitionsDown_clicked();
-	void on_defaultTransitionsAdd_clicked();
-	void on_defaultTransitionsRemove_clicked();
-	void on_defaultTransitionsUp_clicked();
-	void on_defaultTransitionsDown_clicked();
-	void on_transitionOverridecheckBox_stateChanged(int state);
-	void on_adjustActiveTransitionType_stateChanged(int state);
-	void defTransitionDelayValueChanged(int value);
-
-	void on_browseButton_clicked();
-	void on_readFileCheckBox_stateChanged(int state);
-	void on_readPathLineEdit_textChanged(const QString &text);
-	void on_writePathLineEdit_textChanged(const QString &text);
-	void on_browseButton_2_clicked();
-
-	void on_executableUp_clicked();
-	void on_executableDown_clicked();
-	void on_executableAdd_clicked();
-	void on_executableRemove_clicked();
-
-	void on_idleCheckBox_stateChanged(int state);
-	void on_ignoreIdleWindows_currentRowChanged(int idx);
-	void on_ignoreIdleAdd_clicked();
-	void on_ignoreIdleRemove_clicked();
-
-	void on_randomAdd_clicked();
-	void on_randomRemove_clicked();
-
-	void on_fileAdd_clicked();
-	void on_fileRemove_clicked();
-	void on_fileSwitches_currentRowChanged(int idx);
-	void on_fileUp_clicked();
-	void on_fileDown_clicked();
-
-	void on_mediaAdd_clicked();
-	void on_mediaRemove_clicked();
-	void on_mediaUp_clicked();
-	void on_mediaDown_clicked();
-
-	void on_timeAdd_clicked();
-	void on_timeRemove_clicked();
-	void on_timeUp_clicked();
-	void on_timeDown_clicked();
-
-	void on_audioAdd_clicked();
-	void on_audioRemove_clicked();
-	void on_audioUp_clicked();
-	void on_audioDown_clicked();
-	void on_audioFallback_toggled(bool on);
-
-	void on_videoAdd_clicked();
-	void on_videoRemove_clicked();
-	void on_videoUp_clicked();
-	void on_videoDown_clicked();
-	void on_getScreenshot_clicked();
-
-	void on_serverSettings_toggled(bool on);
-	void on_serverPort_valueChanged(int value);
-	void on_lockToIPv4_stateChanged(int state);
-	void on_serverRestart_clicked();
-	void updateServerStatus();
-	void on_clientSettings_toggled(bool on);
-	void on_clientHostname_textChanged(const QString &text);
-	void on_clientPort_valueChanged(int value);
-	void on_sendSceneChange_stateChanged(int state);
-	void on_restrictSend_stateChanged(int state);
-	void on_sendPreview_stateChanged(int state);
-	void on_clientReconnect_clicked();
-	void updateClientStatus();
-
-	void on_sceneGroupAdd_clicked();
-	void on_sceneGroupRemove_clicked();
-	void on_sceneGroupUp_clicked();
-	void on_sceneGroupDown_clicked();
-	void on_sceneGroupName_editingFinished();
-	void on_sceneGroups_currentRowChanged(int idx);
-
-	void on_sceneGroupSceneAdd_clicked();
-	void on_sceneGroupSceneRemove_clicked();
-	void on_sceneGroupSceneUp_clicked();
-	void on_sceneGroupSceneDown_clicked();
-
-	void on_triggerAdd_clicked();
-	void on_triggerRemove_clicked();
-	void on_triggerUp_clicked();
-	void on_triggerDown_clicked();
-
-	void on_priorityUp_clicked();
-	void on_priorityDown_clicked();
-	void on_threadPriority_currentTextChanged(const QString &text);
-
-	void updateScreenRegionCursorPos();
+	void ConnectionAdded(const QString &);
+	void ConnectionRenamed(const QString &oldName, const QString &newName);
+	void ConnectionRemoved(const QString &);
+	void VariableAdded(const QString &);
+	void VariableRenamed(const QString &oldName, const QString &newName);
+	void VariableRemoved(const QString &);
 
 private:
 	bool MacroTabIsInFocus();
@@ -317,29 +173,209 @@ private:
 	MacroSection lastInteracted = MacroSection::CONDITIONS;
 	int currentConditionIdx = -1;
 	int currentActionIdx = -1;
+
+	/* --- End of macro tab section --- */
+
+	/* --- Begin of legacy tab section --- */
+public:
+	void ClearFrames(QListWidget *list);
+	int IgnoreWindowsFindByData(const QString &window);
+	int IgnoreIdleWindowsFindByData(const QString &window);
+	void OpenSequenceExtendEdit(SequenceWidget *sw);
+
+	// Window tab
+public:
+	void SetupTitleTab();
+public slots:
+	void on_windowUp_clicked();
+	void on_windowDown_clicked();
+	void on_windowAdd_clicked();
+	void on_windowRemove_clicked();
+	void on_ignoreWindows_currentRowChanged(int idx);
+	void on_ignoreWindowsAdd_clicked();
+	void on_ignoreWindowsRemove_clicked();
+
+	// Screen region tab
+public:
+	void SetupRegionTab();
+public slots:
+	void SetShowFrames();
+	void SetHideFrames();
+	void on_screenRegionSwitches_currentRowChanged(int idx);
+	void on_showFrame_clicked();
+	void on_screenRegionAdd_clicked();
+	void on_screenRegionRemove_clicked();
+	void on_screenRegionUp_clicked();
+	void on_screenRegionDown_clicked();
+	void updateScreenRegionCursorPos();
+
+	// Pause tab
+public:
+	void SetupPauseTab();
+public slots:
+	void on_pauseUp_clicked();
+	void on_pauseDown_clicked();
+	void on_pauseAdd_clicked();
+	void on_pauseRemove_clicked();
+
+	// Sequence tab
+public:
+	void SetupSequenceTab();
+public slots:
+	void on_sceneSequenceAdd_clicked();
+	void on_sceneSequenceRemove_clicked();
+	void on_sceneSequenceUp_clicked();
+	void on_sceneSequenceDown_clicked();
+	void on_sceneSequenceSave_clicked();
+	void on_sceneSequenceLoad_clicked();
+	void on_sequenceEdit_clicked();
+	void on_sceneSequenceSwitches_itemDoubleClicked(QListWidgetItem *item);
+
+	// Transition tab
+public:
+	void SetupTransitionsTab();
+public slots:
+	void on_transitionsAdd_clicked();
+	void on_transitionsRemove_clicked();
+	void on_transitionsUp_clicked();
+	void on_transitionsDown_clicked();
+	void on_defaultTransitionsAdd_clicked();
+	void on_defaultTransitionsRemove_clicked();
+	void on_defaultTransitionsUp_clicked();
+	void on_defaultTransitionsDown_clicked();
+	void on_transitionOverridecheckBox_stateChanged(int state);
+	void on_adjustActiveTransitionType_stateChanged(int state);
+	void DefTransitionDelayValueChanged(int value);
+
+	// Executable tab
+public:
+	void SetupExecutableTab();
+public slots:
+	void on_executableUp_clicked();
+	void on_executableDown_clicked();
+	void on_executableAdd_clicked();
+	void on_executableRemove_clicked();
+
+	// Idle tab
+public:
+	void SetupIdleTab();
+public slots:
+	void on_idleCheckBox_stateChanged(int state);
+	void on_ignoreIdleWindows_currentRowChanged(int idx);
+	void on_ignoreIdleAdd_clicked();
+	void on_ignoreIdleRemove_clicked();
+
+	// Random tab
+public:
+	void SetupRandomTab();
+public slots:
+	void on_randomAdd_clicked();
+	void on_randomRemove_clicked();
+
+	// File tab
+public:
+	void SetupFileTab();
+public slots:
+	void on_fileAdd_clicked();
+	void on_fileRemove_clicked();
+	void on_fileSwitches_currentRowChanged(int idx);
+	void on_fileUp_clicked();
+	void on_fileDown_clicked();
+	void on_browseButton_clicked();
+	void on_readFileCheckBox_stateChanged(int state);
+	void on_readPathLineEdit_textChanged(const QString &text);
+	void on_writePathLineEdit_textChanged(const QString &text);
+	void on_browseButton_2_clicked();
+
+	// Media tab
+public:
+	void SetupMediaTab();
+public slots:
+	void on_mediaAdd_clicked();
+	void on_mediaRemove_clicked();
+	void on_mediaUp_clicked();
+	void on_mediaDown_clicked();
+
+	// Time tab
+public:
+	void SetupTimeTab();
+public slots:
+	void on_timeAdd_clicked();
+	void on_timeRemove_clicked();
+	void on_timeUp_clicked();
+	void on_timeDown_clicked();
+
+	// Video tab
+public:
+	void SetupAudioTab();
+public slots:
+	void on_audioAdd_clicked();
+	void on_audioRemove_clicked();
+	void on_audioUp_clicked();
+	void on_audioDown_clicked();
+	void on_audioFallback_toggled(bool on);
+
+	// Video tab
+public:
+	void SetupVideoTab();
+public slots:
+	void on_videoAdd_clicked();
+	void on_videoRemove_clicked();
+	void on_videoUp_clicked();
+	void on_videoDown_clicked();
+	void on_getScreenshot_clicked();
+
+	// Scene group tab
+public:
+	void SetupNetworkTab();
+public slots:
+	void on_serverSettings_toggled(bool on);
+	void on_serverPort_valueChanged(int value);
+	void on_lockToIPv4_stateChanged(int state);
+	void on_serverRestart_clicked();
+	void UpdateServerStatus();
+	void on_clientSettings_toggled(bool on);
+	void on_clientHostname_textChanged(const QString &text);
+	void on_clientPort_valueChanged(int value);
+	void on_sendSceneChange_stateChanged(int state);
+	void on_restrictSend_stateChanged(int state);
+	void on_sendPreview_stateChanged(int state);
+	void on_clientReconnect_clicked();
+	void UpdateClientStatus();
+
+	// Scene group tab
+public:
+	void SetupSceneGroupTab();
+	void SetEditSceneGroup(SceneGroup &sg);
+public slots:
+	void on_sceneGroupAdd_clicked();
+	void on_sceneGroupRemove_clicked();
+	void on_sceneGroupUp_clicked();
+	void on_sceneGroupDown_clicked();
+	void on_sceneGroupName_editingFinished();
+	void on_sceneGroups_currentRowChanged(int idx);
+	void on_sceneGroupSceneAdd_clicked();
+	void on_sceneGroupSceneRemove_clicked();
+	void on_sceneGroupSceneUp_clicked();
+	void on_sceneGroupSceneDown_clicked();
+
+signals:
+	void SceneGroupAdded(const QString &name);
+	void SceneGroupRemoved(const QString &name);
+	void SceneGroupRenamed(const QString &oldName, const QString newName);
+
+	// Trigger tab
+public:
+	void SetupTriggerTab();
+public slots:
+	void on_triggerAdd_clicked();
+	void on_triggerRemove_clicked();
+	void on_triggerUp_clicked();
+	void on_triggerDown_clicked();
+
+	/* --- End of legacy tab section --- */
 };
 
 void OpenSettingsWindow();
 
-/******************************************************************************
- * Sceneswitch helper
- ******************************************************************************/
-void setNextTransition(const sceneSwitchInfo &ssi, obs_source_t *currentSource,
-		       transitionData &td);
-void overwriteTransitionOverride(const sceneSwitchInfo &ssi,
-				 transitionData &td);
-void restoreTransitionOverride(obs_source_t *scene, const transitionData &td);
-void switchScene(const sceneSwitchInfo &ssi, bool force = false);
-void switchPreviewScene(const OBSWeakSource &ws);
-
-/******************************************************************************
- * Settings helper
- ******************************************************************************/
-void AskForBackup(obs_data_t *obj);
-
-/******************************************************************************
- * Main SwitcherData
- ******************************************************************************/
-struct SwitcherData;
-extern SwitcherData *switcher;
-SwitcherData *GetSwitcher();
+} // namespace advss

src/general.cpp

@@ -1,11 +1,13 @@
 #include "advanced-scene-switcher.hpp"
+#include "switcher-data.hpp"
 #include "status-control.hpp"
 #include "file-selection.hpp"
 #include "utility.hpp"
 #include "version.h"
 
 #include <QFileDialog>
-#include <QStandardPaths>
+
+namespace advss {
 
 void AdvSceneSwitcher::reject()
 {
@@ -30,7 +32,7 @@ void AdvSceneSwitcher::on_noMatchDontSwitch_clicked()
 	}
 
 	std::lock_guard<std::mutex> lock(switcher->m);
-	switcher->switchIfNotMatching = NO_SWITCH;
+	switcher->switchIfNotMatching = SwitcherData::NoMatch::NO_SWITCH;
 	ui->noMatchSwitchScene->setEnabled(false);
 	ui->randomDisabledWarning->setVisible(true);
 }
@@ -42,7 +44,7 @@ void AdvSceneSwitcher::on_noMatchSwitch_clicked()
 	}
 
 	std::lock_guard<std::mutex> lock(switcher->m);
-	switcher->switchIfNotMatching = SWITCH;
+	switcher->switchIfNotMatching = SwitcherData::NoMatch::SWITCH;
 	ui->noMatchSwitchScene->setEnabled(true);
 	UpdateNonMatchingScene(ui->noMatchSwitchScene->currentText());
 	ui->randomDisabledWarning->setVisible(true);
@@ -55,7 +57,7 @@ void AdvSceneSwitcher::on_noMatchRandomSwitch_clicked()
 	}
 
 	std::lock_guard<std::mutex> lock(switcher->m);
-	switcher->switchIfNotMatching = RANDOM_SWITCH;
+	switcher->switchIfNotMatching = SwitcherData::NoMatch::RANDOM_SWITCH;
 	ui->noMatchSwitchScene->setEnabled(false);
 	ui->randomDisabledWarning->setVisible(false);
 }
@@ -87,7 +89,8 @@ void AdvSceneSwitcher::on_startupBehavior_currentIndexChanged(int index)
 	}
 
 	std::lock_guard<std::mutex> lock(switcher->m);
-	switcher->startupBehavior = (StartupBehavior)index;
+	switcher->startupBehavior =
+		static_cast<SwitcherData::StartupBehavior>(index);
 }
 
 void AdvSceneSwitcher::on_autoStartEvent_currentIndexChanged(int index)
@@ -97,7 +100,7 @@ void AdvSceneSwitcher::on_autoStartEvent_currentIndexChanged(int index)
 	}
 
 	std::lock_guard<std::mutex> lock(switcher->m);
-	switcher->autoStartEvent = static_cast<AutoStartEvent>(index);
+	switcher->autoStartEvent = static_cast<SwitcherData::AutoStart>(index);
 }
 
 void AdvSceneSwitcher::on_noMatchSwitchScene_currentTextChanged(
@@ -181,7 +184,7 @@ void AdvSceneSwitcher::on_warnPluginLoadFailure_stateChanged(int state)
 	switcher->warnPluginLoadFailure = state;
 }
 
-bool isLegacyTab(const QString &name)
+static bool isLegacyTab(const QString &name)
 {
 	return name == obs_module_text(
 			       "AdvSceneSwitcher.sceneGroupTab.title") ||
@@ -226,7 +229,7 @@ void AdvSceneSwitcher::on_hideLegacyTabs_stateChanged(int state)
 	}
 }
 
-void AdvSceneSwitcher::setDeprecationWarnings()
+void AdvSceneSwitcher::SetDeprecationWarnings()
 {
 	QString toolTip =
 		switcher->disableHints
@@ -240,70 +243,13 @@ void AdvSceneSwitcher::setDeprecationWarnings()
 	}
 }
 
-QString getDefaultSaveLocation()
-{
-	QString desktopPath = QStandardPaths::writableLocation(
-		QStandardPaths::DesktopLocation);
-
-	auto scName = obs_frontend_get_current_scene_collection();
-	QString sceneCollectionName(scName);
-	bfree(scName);
-
-	auto timestamp = QDateTime::currentDateTime();
-	auto path = desktopPath + "/adv-ss-" + sceneCollectionName + "-" +
-		    timestamp.toString("yyyy.MM.dd.hh.mm.ss");
-
-	// Check if scene collection name contains invalid path characters
-	QFile file(path);
-	if (file.exists()) {
-		return path;
-	}
-
-	bool validPath = file.open(QIODevice::WriteOnly);
-	if (validPath) {
-		file.remove();
-		return path;
-	}
-
-	return desktopPath + "/adv-ss-" +
-	       timestamp.toString("yyyy.MM.dd.hh.mm.ss");
-}
-
-void AskForBackup(obs_data_t *obj)
-{
-	bool backupSettings = DisplayMessage(
-		obs_module_text("AdvSceneSwitcher.askBackup"), true);
-
-	if (!backupSettings) {
-		return;
-	}
-
-	QString path = QFileDialog::getSaveFileName(
-		nullptr,
-		obs_module_text(
-			"AdvSceneSwitcher.generalTab.saveOrLoadsettings.importWindowTitle"),
-		getDefaultSaveLocation(),
-		obs_module_text(
-			"AdvSceneSwitcher.generalTab.saveOrLoadsettings.textType"));
-	if (path.isEmpty()) {
-		return;
-	}
-
-	QFile file(path);
-	if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
-		return;
-	}
-
-	obs_data_save_json(obj, file.fileName().toUtf8().constData());
-}
-
 void AdvSceneSwitcher::on_exportSettings_clicked()
 {
 	QString directory = QFileDialog::getSaveFileName(
 		this,
 		tr(obs_module_text(
 			"AdvSceneSwitcher.generalTab.saveOrLoadsettings.exportWindowTitle")),
-		getDefaultSaveLocation(),
+		GetDefaultSettingsSaveLocation(),
 		tr(obs_module_text(
 			"AdvSceneSwitcher.generalTab.saveOrLoadsettings.textType")));
 	if (directory.isEmpty()) {
@@ -316,7 +262,7 @@ void AdvSceneSwitcher::on_exportSettings_clicked()
 	}
 
 	obs_data_t *obj = obs_data_create();
-	switcher->saveSettings(obj);
+	switcher->SaveSettings(obj);
 	obs_data_save_json(obj, file.fileName().toUtf8().constData());
 	obs_data_release(obj);
 }
@@ -356,7 +302,7 @@ void AdvSceneSwitcher::on_importSettings_clicked()
 	}
 
 	std::lock_guard<std::mutex> lock(switcher->m);
-	switcher->loadSettings(obj);
+	switcher->LoadSettings(obj);
 	obs_data_release(obj);
 	switcher->lastImportPath = path.toStdString();
 
@@ -372,7 +318,7 @@ void AdvSceneSwitcher::on_importSettings_clicked()
 	}
 }
 
-int findTabIndex(QTabWidget *tabWidget, int pos)
+static int findTabIndex(QTabWidget *tabWidget, int pos)
 {
 	int at = -1;
 
@@ -446,10 +392,10 @@ int findTabIndex(QTabWidget *tabWidget, int pos)
 	return at;
 }
 
-void AdvSceneSwitcher::setTabOrder()
+void AdvSceneSwitcher::SetTabOrder()
 {
-	if (!switcher->tabOrderValid()) {
-		switcher->resetTabOrder();
+	if (!switcher->TabOrderValid()) {
+		switcher->ResetTabOrder();
 	}
 
 	QTabBar *bar = ui->tabWidget->tabBar();
@@ -464,22 +410,22 @@ void AdvSceneSwitcher::setTabOrder()
 	connect(bar, &QTabBar::tabMoved, this, &AdvSceneSwitcher::on_tabMoved);
 }
 
-void AdvSceneSwitcher::setCurrentTab()
+void AdvSceneSwitcher::SetCurrentTab()
 {
 	if (switcher->lastOpenedTab >= 0) {
 		ui->tabWidget->setCurrentIndex(switcher->lastOpenedTab);
 	}
 }
 
-void AdvSceneSwitcher::restoreWindowGeo()
+void AdvSceneSwitcher::RestoreWindowGeo()
 {
-	if (switcher->saveWindowGeo && windowPosValid(switcher->windowPos)) {
+	if (switcher->saveWindowGeo && WindowPosValid(switcher->windowPos)) {
 		this->resize(switcher->windowSize);
 		this->move(switcher->windowPos);
 	}
 }
 
-void AdvSceneSwitcher::checkFirstTimeSetup()
+void AdvSceneSwitcher::CheckFirstTimeSetup()
 {
 	if (switcher->firstBoot && !switcher->disableHints) {
 		switcher->firstBoot = false;
@@ -500,7 +446,7 @@ void AdvSceneSwitcher::on_tabMoved(int from, int to)
 void AdvSceneSwitcher::on_tabWidget_currentChanged(int)
 {
 	switcher->showFrame = false;
-	clearFrames(ui->screenRegionSwitches);
+	ClearFrames(ui->screenRegionSwitches);
 	SetShowFrames();
 }
 
@@ -537,7 +483,7 @@ void AdvSceneSwitcher::on_adjustActiveTransitionType_stateChanged(int state)
 	switcher->adjustActiveTransitionType = state;
 }
 
-void SwitcherData::loadSettings(obs_data_t *obj)
+void SwitcherData::LoadSettings(obs_data_t *obj)
 {
 	if (!obj) {
 		return;
@@ -546,9 +492,9 @@ void SwitcherData::loadSettings(obs_data_t *obj)
 	// Needs to be loaded before any entries which might rely on scene group
 	// selections to be available.
 	loadSceneGroups(obj);
-	loadVariables(obj);
-	loadConnections(obj);
-	loadMacros(obj);
+	LoadVariables(obj);
+	LoadConnections(obj);
+	LoadMacros(obj);
 	loadWindowTitleSwitches(obj);
 	loadScreenRegionSwitches(obj);
 	loadPauseSwitches(obj);
@@ -564,24 +510,24 @@ void SwitcherData::loadSettings(obs_data_t *obj)
 	loadVideoSwitches(obj);
 	loadNetworkSettings(obj);
 	loadSceneTriggers(obj);
-	loadGeneralSettings(obj);
-	loadHotkeys(obj);
-	loadUISettings(obj);
+	LoadGeneralSettings(obj);
+	LoadHotkeys(obj);
+	LoadUISettings(obj);
 
 	// Reset on startup and scene collection change
 	switcher->lastOpenedTab = -1;
 }
 
-void SwitcherData::saveSettings(obs_data_t *obj)
+void SwitcherData::SaveSettings(obs_data_t *obj)
 {
 	if (!obj) {
 		return;
 	}
 
 	saveSceneGroups(obj);
-	saveMacros(obj);
-	saveConnections(obj);
-	saveVariables(obj);
+	SaveMacros(obj);
+	SaveConnections(obj);
+	SaveVariables(obj);
 	saveWindowTitleSwitches(obj);
 	saveScreenRegionSwitches(obj);
 	savePauseSwitches(obj);
@@ -597,27 +543,29 @@ void SwitcherData::saveSettings(obs_data_t *obj)
 	saveVideoSwitches(obj);
 	saveNetworkSwitches(obj);
 	saveSceneTriggers(obj);
-	saveGeneralSettings(obj);
-	saveHotkeys(obj);
-	saveUISettings(obj);
-	saveVersion(obj, g_GIT_SHA1);
+	SaveGeneralSettings(obj);
+	SaveHotkeys(obj);
+	SaveUISettings(obj);
+	SaveVersion(obj, g_GIT_SHA1);
 }
 
-void SwitcherData::saveGeneralSettings(obs_data_t *obj)
+void SwitcherData::SaveGeneralSettings(obs_data_t *obj)
 {
 	obs_data_set_int(obj, "interval", interval);
 
 	std::string nonMatchingSceneName = GetWeakSourceName(nonMatchingScene);
 	obs_data_set_string(obj, "non_matching_scene",
 			    nonMatchingSceneName.c_str());
-	obs_data_set_int(obj, "switch_if_not_matching", switchIfNotMatching);
+	obs_data_set_int(obj, "switch_if_not_matching",
+			 static_cast<int>(switchIfNotMatching));
 	noMatchDelay.Save(obj, "noMatchDelay");
 
 	cooldown.Save(obj, "cooldown");
 
 	obs_data_set_bool(obj, "active", sceneColletionStop ? true : !stop);
 	sceneColletionStop = false;
-	obs_data_set_int(obj, "startup_behavior", startupBehavior);
+	obs_data_set_int(obj, "startup_behavior",
+			 static_cast<int>(startupBehavior));
 
 	obs_data_set_int(obj, "autoStartEvent",
 			 static_cast<int>(autoStartEvent));
@@ -651,12 +599,13 @@ void SwitcherData::saveGeneralSettings(obs_data_t *obj)
 	obs_data_set_string(obj, "lastImportPath", lastImportPath.c_str());
 }
 
-void SwitcherData::loadGeneralSettings(obs_data_t *obj)
+void SwitcherData::LoadGeneralSettings(obs_data_t *obj)
 {
 	obs_data_set_default_int(obj, "interval", default_interval);
 	interval = obs_data_get_int(obj, "interval");
 
-	obs_data_set_default_int(obj, "switch_if_not_matching", NO_SWITCH);
+	obs_data_set_default_int(obj, "switch_if_not_matching",
+				 static_cast<int>(NoMatch::NO_SWITCH));
 	switchIfNotMatching =
 		(NoMatch)obs_data_get_int(obj, "switch_if_not_matching");
 	std::string nonMatchingSceneName =
@@ -669,15 +618,15 @@ void SwitcherData::loadGeneralSettings(obs_data_t *obj)
 	stop = !obs_data_get_bool(obj, "active");
 	startupBehavior =
 		(StartupBehavior)obs_data_get_int(obj, "startup_behavior");
-	if (startupBehavior == START) {
+	if (startupBehavior == StartupBehavior::START) {
 		stop = false;
 	}
-	if (startupBehavior == STOP) {
+	if (startupBehavior == StartupBehavior::STOP) {
 		stop = true;
 	}
 
-	autoStartEvent = static_cast<AutoStartEvent>(
-		obs_data_get_int(obj, "autoStartEvent"));
+	autoStartEvent =
+		static_cast<AutoStart>(obs_data_get_int(obj, "autoStartEvent"));
 
 	verbose = obs_data_get_bool(obj, "verbose");
 	showSystemTrayNotifications =
@@ -688,53 +637,17 @@ void SwitcherData::loadGeneralSettings(obs_data_t *obj)
 	obs_data_set_default_bool(obj, "hideLegacyTabs", true);
 	hideLegacyTabs = obs_data_get_bool(obj, "hideLegacyTabs");
 
-	obs_data_set_default_int(obj, "priority0", default_priority_0);
-	obs_data_set_default_int(obj, "priority1", default_priority_1);
-	obs_data_set_default_int(obj, "priority2", default_priority_2);
-	obs_data_set_default_int(obj, "priority3", default_priority_3);
-	obs_data_set_default_int(obj, "priority4", default_priority_4);
-	obs_data_set_default_int(obj, "priority5", default_priority_5);
-	obs_data_set_default_int(obj, "priority6", default_priority_6);
-	obs_data_set_default_int(obj, "priority7", default_priority_7);
-	obs_data_set_default_int(obj, "priority8", default_priority_8);
-
-	functionNamesByPriority[0] = (obs_data_get_int(obj, "priority0"));
-	functionNamesByPriority[1] = (obs_data_get_int(obj, "priority1"));
-	functionNamesByPriority[2] = (obs_data_get_int(obj, "priority2"));
-	functionNamesByPriority[3] = (obs_data_get_int(obj, "priority3"));
-	functionNamesByPriority[4] = (obs_data_get_int(obj, "priority4"));
-	functionNamesByPriority[5] = (obs_data_get_int(obj, "priority5"));
-	functionNamesByPriority[6] = (obs_data_get_int(obj, "priority6"));
-	functionNamesByPriority[7] = (obs_data_get_int(obj, "priority7"));
-	functionNamesByPriority[8] = (obs_data_get_int(obj, "priority8"));
-	functionNamesByPriority[9] = (obs_data_get_int(obj, "priority9"));
-	functionNamesByPriority[10] = (obs_data_get_int(obj, "priority10"));
-	if (!prioFuncsValid()) {
-		functionNamesByPriority[0] = (default_priority_0);
-		functionNamesByPriority[1] = (default_priority_1);
-		functionNamesByPriority[2] = (default_priority_2);
-		functionNamesByPriority[3] = (default_priority_3);
-		functionNamesByPriority[4] = (default_priority_4);
-		functionNamesByPriority[5] = (default_priority_5);
-		functionNamesByPriority[6] = (default_priority_6);
-		functionNamesByPriority[7] = (default_priority_7);
-		functionNamesByPriority[8] = (default_priority_8);
-		functionNamesByPriority[9] = (default_priority_9);
-		functionNamesByPriority[10] = (default_priority_10);
+	SetDefaultFunctionPriorities(obj);
+	if (!PrioFuncsValid()) {
+		functionNamesByPriority = GetDefaultFunctionPriorityList();
 	}
 
 	obs_data_set_default_int(obj, "threadPriority",
 				 QThread::NormalPriority);
 	threadPriority = obs_data_get_int(obj, "threadPriority");
 
-	// TODO: Remove this fallback in future version
-	if (obs_data_has_user_value(obj, "tansitionOverrideOverride")) {
-		transitionOverrideOverride =
-			obs_data_get_bool(obj, "tansitionOverrideOverride");
-	} else {
-		transitionOverrideOverride =
-			obs_data_get_bool(obj, "transitionOverrideOverride");
-	}
+	transitionOverrideOverride =
+		obs_data_get_bool(obj, "transitionOverrideOverride");
 	adjustActiveTransitionType =
 		obs_data_get_bool(obj, "adjustActiveTransitionType");
 
@@ -747,7 +660,8 @@ void SwitcherData::loadGeneralSettings(obs_data_t *obj)
 	lastImportPath = obs_data_get_string(obj, "lastImportPath");
 }
 
-void saveSplitterPos(QList<int> &sizes, obs_data_t *obj, const std::string name)
+static void saveSplitterPos(QList<int> &sizes, obs_data_t *obj,
+			    const std::string name)
 {
 	auto array = obs_data_array_create();
 	for (int i = 0; i < sizes.count(); ++i) {
@@ -760,7 +674,8 @@ void saveSplitterPos(QList<int> &sizes, obs_data_t *obj, const std::string name)
 	obs_data_array_release(array);
 }
 
-void loadSplitterPos(QList<int> &sizes, obs_data_t *obj, const std::string name)
+static void loadSplitterPos(QList<int> &sizes, obs_data_t *obj,
+			    const std::string name)
 {
 	sizes.clear();
 	obs_data_array_t *array = obs_data_get_array(obj, name.c_str());
@@ -773,7 +688,7 @@ void loadSplitterPos(QList<int> &sizes, obs_data_t *obj, const std::string name)
 	obs_data_array_release(array);
 }
 
-void SwitcherData::saveUISettings(obs_data_t *obj)
+void SwitcherData::SaveUISettings(obs_data_t *obj)
 {
 	obs_data_set_int(obj, "generalTabPos", tabOrder[0]);
 	obs_data_set_int(obj, "macroTabPos", tabOrder[1]);
@@ -806,7 +721,7 @@ void SwitcherData::saveUISettings(obs_data_t *obj)
 			"macroListMacroEditSplitterPosition");
 }
 
-void SwitcherData::loadUISettings(obs_data_t *obj)
+void SwitcherData::LoadUISettings(obs_data_t *obj)
 {
 	obs_data_set_default_int(obj, "generalTabPos", 0);
 	obs_data_set_default_int(obj, "macroTabPos", 1);
@@ -847,8 +762,8 @@ void SwitcherData::loadUISettings(obs_data_t *obj)
 	tabOrder.emplace_back((int)(obs_data_get_int(obj, "sceneGroupTabPos")));
 	tabOrder.emplace_back((int)(obs_data_get_int(obj, "triggerTabPos")));
 
-	if (!tabOrderValid()) {
-		resetTabOrder();
+	if (!TabOrderValid()) {
+		ResetTabOrder();
 	}
 
 	saveWindowGeo = obs_data_get_bool(obj, "saveWindowGeo");
@@ -862,7 +777,7 @@ void SwitcherData::loadUISettings(obs_data_t *obj)
 			"macroListMacroEditSplitterPosition");
 }
 
-bool SwitcherData::tabOrderValid()
+bool SwitcherData::TabOrderValid()
 {
 	auto tmp = std::vector<int>(tab_count);
 	std::iota(tmp.begin(), tmp.end(), 0);
@@ -876,13 +791,13 @@ bool SwitcherData::tabOrderValid()
 	return true;
 }
 
-void SwitcherData::resetTabOrder()
+void SwitcherData::ResetTabOrder()
 {
 	tabOrder = std::vector<int>(tab_count);
 	std::iota(tabOrder.begin(), tabOrder.end(), 0);
 }
 
-void SwitcherData::checkNoMatchSwitch(bool &match, OBSWeakSource &scene,
+void SwitcherData::CheckNoMatchSwitch(bool &match, OBSWeakSource &scene,
 				      OBSWeakSource &transition, int &sleep)
 {
 	if (match) {
@@ -894,12 +809,12 @@ void SwitcherData::checkNoMatchSwitch(bool &match, OBSWeakSource &scene,
 		return;
 	}
 
-	if (switchIfNotMatching == SWITCH && nonMatchingScene) {
+	if (switchIfNotMatching == NoMatch::SWITCH && nonMatchingScene) {
 		match = true;
 		scene = nonMatchingScene;
 		transition = nullptr;
 	}
-	if (switchIfNotMatching == RANDOM_SWITCH) {
+	if (switchIfNotMatching == NoMatch::RANDOM_SWITCH) {
 		match = checkRandom(scene, transition, sleep);
 	}
 }
@@ -918,7 +833,7 @@ void SwitcherData::checkSwitchCooldown(bool &match)
 	}
 }
 
-void populateStartupBehavior(QComboBox *cb)
+static void populateStartupBehavior(QComboBox *cb)
 {
 	cb->addItem(obs_module_text(
 		"AdvSceneSwitcher.generalTab.status.onStartup.asLastRun"));
@@ -928,7 +843,7 @@ void populateStartupBehavior(QComboBox *cb)
 		"AdvSceneSwitcher.generalTab.status.onStartup.doNotStart"));
 }
 
-void populateAutoStartEventSelection(QComboBox *cb)
+static void populateAutoStartEventSelection(QComboBox *cb)
 {
 	cb->addItem(obs_module_text(
 		"AdvSceneSwitcher.generalTab.status.autoStart.never"));
@@ -940,52 +855,8 @@ void populateAutoStartEventSelection(QComboBox *cb)
 		"AdvSceneSwitcher.generalTab.status.autoStart.recordingAndStreaming"));
 }
 
-void AdvSceneSwitcher::setupGeneralTab()
+static void populatePriorityFunctionList(QListWidget *list)
 {
-	populateSceneSelection(ui->noMatchSwitchScene, false);
-
-	if (switcher->switchIfNotMatching == SWITCH) {
-		ui->noMatchSwitch->setChecked(true);
-		ui->noMatchSwitchScene->setEnabled(true);
-	} else if (switcher->switchIfNotMatching == NO_SWITCH) {
-		ui->noMatchDontSwitch->setChecked(true);
-		ui->noMatchSwitchScene->setEnabled(false);
-	} else {
-		ui->noMatchRandomSwitch->setChecked(true);
-		ui->noMatchSwitchScene->setEnabled(false);
-	}
-	ui->noMatchSwitchScene->setCurrentText(
-		GetWeakSourceName(switcher->nonMatchingScene).c_str());
-
-	DurationSelection *noMatchDelay = new DurationSelection();
-	noMatchDelay->SetDuration(switcher->noMatchDelay);
-	noMatchDelay->setToolTip(obs_module_text(
-		"AdvSceneSwitcher.generalTab.generalBehavior.onNoMetDelayTooltip"));
-	ui->noMatchLayout->addWidget(noMatchDelay);
-	QWidget::connect(noMatchDelay,
-			 SIGNAL(DurationChanged(const Duration &)), this,
-			 SLOT(NoMatchDelayDurationChanged(const Duration &)));
-
-	ui->checkInterval->setValue(switcher->interval);
-
-	DurationSelection *cooldownTime = new DurationSelection();
-	cooldownTime->SetDuration(switcher->cooldown);
-	cooldownTime->setToolTip(obs_module_text(
-		"AdvSceneSwitcher.generalTab.generalBehavior.cooldownHint"));
-	ui->cooldownLayout->addWidget(cooldownTime);
-	ui->cooldownLayout->addStretch();
-	QWidget::connect(cooldownTime,
-			 SIGNAL(DurationChanged(const Duration &)), this,
-			 SLOT(CooldownDurationChanged(const Duration &)));
-
-	ui->verboseLogging->setChecked(switcher->verbose);
-	ui->saveWindowGeo->setChecked(switcher->saveWindowGeo);
-	ui->showTrayNotifications->setChecked(
-		switcher->showSystemTrayNotifications);
-	ui->uiHintsDisable->setChecked(switcher->disableHints);
-	ui->warnPluginLoadFailure->setChecked(switcher->warnPluginLoadFailure);
-	ui->hideLegacyTabs->setChecked(switcher->hideLegacyTabs);
-
 	for (int p : switcher->functionNamesByPriority) {
 		std::string s = "";
 		switch (p) {
@@ -1035,26 +906,114 @@ void AdvSceneSwitcher::setupGeneralTab()
 			break;
 		}
 		QString text(s.c_str());
-		QListWidgetItem *item =
-			new QListWidgetItem(text, ui->priorityList);
+		QListWidgetItem *item = new QListWidgetItem(text, list);
 		item->setData(Qt::UserRole, text);
 	}
+}
 
+static void populateThreadPriorityList(QComboBox *list)
+{
 	for (int i = 0; i < (int)switcher->threadPriorities.size(); ++i) {
-		ui->threadPriority->addItem(
-			switcher->threadPriorities[i].name.c_str());
-		ui->threadPriority->setItemData(
+		list->addItem(switcher->threadPriorities[i].name.c_str());
+		list->setItemData(
 			i, switcher->threadPriorities[i].description.c_str(),
 			Qt::ToolTipRole);
 		if (switcher->threadPriority ==
 		    switcher->threadPriorities[i].value) {
-			ui->threadPriority->setCurrentText(
+			list->setCurrentText(
 				switcher->threadPriorities[i].name.c_str());
 		}
 	}
+}
+
+static bool isGeneralTab(const QString &name)
+{
+	return name == obs_module_text("AdvSceneSwitcher.generalTab.title");
+}
+
+static int getGeneralTabIdx(QTabWidget *tabWidget)
+{
+	for (int idx = 0; idx < tabWidget->count(); idx++) {
+		if (isGeneralTab(tabWidget->tabText(idx))) {
+			return idx;
+		}
+	}
+	return -1;
+}
+
+static void setupGeneralTabInactiveWarning(QTabWidget *tabs)
+{
+	auto callback = [tabs]() {
+		const bool isRunning = switcher && switcher->th &&
+				       switcher->th->isRunning();
+		auto idx = getGeneralTabIdx(tabs);
+		tabs->setTabIcon(
+			idx,
+			isRunning ? QIcon()
+				  : QIcon::fromTheme(
+					    "obs",
+					    QIcon(":/res/images/warning.svg")));
+	};
+
+	auto inactiveTimer = new QTimer(tabs);
+	inactiveTimer->setInterval(1000);
+	QObject::connect(inactiveTimer, &QTimer::timeout, callback);
+	inactiveTimer->start();
+}
+
+void AdvSceneSwitcher::SetupGeneralTab()
+{
+	PopulateSceneSelection(ui->noMatchSwitchScene, false);
+
+	if (switcher->switchIfNotMatching == SwitcherData::NoMatch::SWITCH) {
+		ui->noMatchSwitch->setChecked(true);
+		ui->noMatchSwitchScene->setEnabled(true);
+	} else if (switcher->switchIfNotMatching ==
+		   SwitcherData::NoMatch::NO_SWITCH) {
+		ui->noMatchDontSwitch->setChecked(true);
+		ui->noMatchSwitchScene->setEnabled(false);
+	} else {
+		ui->noMatchRandomSwitch->setChecked(true);
+		ui->noMatchSwitchScene->setEnabled(false);
+	}
+	ui->noMatchSwitchScene->setCurrentText(
+		GetWeakSourceName(switcher->nonMatchingScene).c_str());
+
+	DurationSelection *noMatchDelay = new DurationSelection();
+	noMatchDelay->SetDuration(switcher->noMatchDelay);
+	noMatchDelay->setToolTip(obs_module_text(
+		"AdvSceneSwitcher.generalTab.generalBehavior.onNoMetDelayTooltip"));
+	ui->noMatchLayout->addWidget(noMatchDelay);
+	QWidget::connect(noMatchDelay,
+			 SIGNAL(DurationChanged(const Duration &)), this,
+			 SLOT(NoMatchDelayDurationChanged(const Duration &)));
+
+	ui->checkInterval->setValue(switcher->interval);
+
+	DurationSelection *cooldownTime = new DurationSelection();
+	cooldownTime->SetDuration(switcher->cooldown);
+	cooldownTime->setToolTip(obs_module_text(
+		"AdvSceneSwitcher.generalTab.generalBehavior.cooldownHint"));
+	ui->cooldownLayout->addWidget(cooldownTime);
+	ui->cooldownLayout->addStretch();
+	QWidget::connect(cooldownTime,
+			 SIGNAL(DurationChanged(const Duration &)), this,
+			 SLOT(CooldownDurationChanged(const Duration &)));
+
+	ui->verboseLogging->setChecked(switcher->verbose);
+	ui->saveWindowGeo->setChecked(switcher->saveWindowGeo);
+	ui->showTrayNotifications->setChecked(
+		switcher->showSystemTrayNotifications);
+	ui->uiHintsDisable->setChecked(switcher->disableHints);
+	ui->warnPluginLoadFailure->setChecked(switcher->warnPluginLoadFailure);
+	ui->hideLegacyTabs->setChecked(switcher->hideLegacyTabs);
+
+	populatePriorityFunctionList(ui->priorityList);
+	populateThreadPriorityList(ui->threadPriority);
 
 	populateStartupBehavior(ui->startupBehavior);
-	ui->startupBehavior->setCurrentIndex(switcher->startupBehavior);
+	ui->startupBehavior->setCurrentIndex(
+		static_cast<int>(switcher->startupBehavior));
 
 	populateAutoStartEventSelection(ui->autoStartEvent);
 	ui->autoStartEvent->setCurrentIndex(
@@ -1071,6 +1030,10 @@ void AdvSceneSwitcher::setupGeneralTab()
 	// Hide the now empty invisible shell of the statusControl widget
 	// as otherwise it could block user input
 	statusControl->hide();
+	setupGeneralTabInactiveWarning(ui->tabWidget);
 
+	MinimizeSizeOfColumn(ui->statusLayout, 0);
 	setWindowTitle(windowTitle() + " - " + g_GIT_TAG);
 }
+
+} // namespace advss

src/hotkey.cpp

@@ -1,9 +1,12 @@
 #include "hotkey.hpp"
 #include "advanced-scene-switcher.hpp"
+#include "switcher-data.hpp"
 #include <obs-module.h>
 #include <fstream>
 #include <regex>
 
+namespace advss {
+
 std::vector<std::weak_ptr<Hotkey>> Hotkey::_registeredHotkeys = {};
 uint32_t Hotkey::_hotkeyCounter = 1;
 
@@ -117,7 +120,7 @@ void Hotkey::ClearAllHotkeys()
 	_registeredHotkeys.clear();
 }
 
-void startHotkeyFunc(void *, obs_hotkey_id, obs_hotkey_t *, bool pressed)
+static void startHotkeyFunc(void *, obs_hotkey_id, obs_hotkey_t *, bool pressed)
 {
 	if (pressed) {
 		if (!(switcher->th && switcher->th->isRunning())) {
@@ -126,7 +129,7 @@ void startHotkeyFunc(void *, obs_hotkey_id, obs_hotkey_t *, bool pressed)
 	}
 }
 
-void stopHotkeyFunc(void *, obs_hotkey_id, obs_hotkey_t *, bool pressed)
+static void stopHotkeyFunc(void *, obs_hotkey_id, obs_hotkey_t *, bool pressed)
 {
 	if (pressed) {
 		if (switcher->th && switcher->th->isRunning()) {
@@ -135,8 +138,8 @@ void stopHotkeyFunc(void *, obs_hotkey_id, obs_hotkey_t *, bool pressed)
 	}
 }
 
-void startStopToggleHotkeyFunc(void *, obs_hotkey_id, obs_hotkey_t *,
-			       bool pressed)
+static void startStopToggleHotkeyFunc(void *, obs_hotkey_id, obs_hotkey_t *,
+				      bool pressed)
 {
 	if (pressed) {
 		if (switcher->th && switcher->th->isRunning()) {
@@ -147,8 +150,8 @@ void startStopToggleHotkeyFunc(void *, obs_hotkey_id, obs_hotkey_t *,
 	}
 }
 
-void upMacroSegmentHotkeyFunc(void *, obs_hotkey_id, obs_hotkey_t *,
-			      bool pressed)
+static void upMacroSegmentHotkeyFunc(void *, obs_hotkey_id, obs_hotkey_t *,
+				     bool pressed)
 {
 	if (pressed && switcher->settingsWindowOpened &&
 	    AdvSceneSwitcher::window) {
@@ -158,8 +161,8 @@ void upMacroSegmentHotkeyFunc(void *, obs_hotkey_id, obs_hotkey_t *,
 	}
 }
 
-void downMacroSegmentHotkeyFunc(void *, obs_hotkey_id, obs_hotkey_t *,
-				bool pressed)
+static void downMacroSegmentHotkeyFunc(void *, obs_hotkey_id, obs_hotkey_t *,
+				       bool pressed)
 {
 	if (pressed && switcher->settingsWindowOpened &&
 	    AdvSceneSwitcher::window) {
@@ -169,8 +172,8 @@ void downMacroSegmentHotkeyFunc(void *, obs_hotkey_id, obs_hotkey_t *,
 	}
 }
 
-void removeMacroSegmentHotkeyFunc(void *, obs_hotkey_id, obs_hotkey_t *,
-				  bool pressed)
+static void removeMacroSegmentHotkeyFunc(void *, obs_hotkey_id, obs_hotkey_t *,
+					 bool pressed)
 {
 	if (pressed && switcher->settingsWindowOpened &&
 	    AdvSceneSwitcher::window) {
@@ -180,7 +183,7 @@ void removeMacroSegmentHotkeyFunc(void *, obs_hotkey_id, obs_hotkey_t *,
 	}
 }
 
-void registerHotkeys()
+static void registerHotkeys()
 {
 	switcher->startHotkey = obs_hotkey_register_frontend(
 		"startSwitcherHotkey",
@@ -213,14 +216,14 @@ void registerHotkeys()
 	switcher->hotkeysRegistered = true;
 }
 
-void saveHotkey(obs_data_t *obj, obs_hotkey_id id, const char *name)
+static void saveHotkey(obs_data_t *obj, obs_hotkey_id id, const char *name)
 {
 	obs_data_array_t *a = obs_hotkey_save(id);
 	obs_data_set_array(obj, name, a);
 	obs_data_array_release(a);
 }
 
-void SwitcherData::saveHotkeys(obs_data_t *obj)
+void SwitcherData::SaveHotkeys(obs_data_t *obj)
 {
 	saveHotkey(obj, startHotkey, "startHotkey");
 	saveHotkey(obj, stopHotkey, "stopHotkey");
@@ -230,14 +233,14 @@ void SwitcherData::saveHotkeys(obs_data_t *obj)
 	saveHotkey(obj, removeMacroSegment, "removeMacroSegmentHotkey");
 }
 
-void loadHotkey(obs_data_t *obj, obs_hotkey_id id, const char *name)
+static void loadHotkey(obs_data_t *obj, obs_hotkey_id id, const char *name)
 {
 	obs_data_array_t *a = obs_data_get_array(obj, name);
 	obs_hotkey_load(id, a);
 	obs_data_array_release(a);
 }
 
-void SwitcherData::loadHotkeys(obs_data_t *obj)
+void SwitcherData::LoadHotkeys(obs_data_t *obj)
 {
 	if (!hotkeysRegistered) {
 		registerHotkeys();
@@ -249,3 +252,5 @@ void SwitcherData::loadHotkeys(obs_data_t *obj)
 	loadHotkey(obj, downMacroSegment, "downMacroSegmentHotkey");
 	loadHotkey(obj, removeMacroSegment, "removeMacroSegmentHotkey");
 }
+
+} // namespace advss

src/hotkey.hpp

@@ -5,6 +5,8 @@
 #include <vector>
 #include <chrono>
 
+namespace advss {
+
 extern bool canSimulateKeyPresses;
 
 class Hotkey {
@@ -161,4 +163,4 @@ enum class HotkeyType {
 	Key_NumpadEnter
 };
 
-void registerHotkeys();
+} // namespace advss

src/legacy/scene-group.cpp

@@ -3,9 +3,12 @@
 #include <random>
 
 #include "advanced-scene-switcher.hpp"
+#include "switcher-data.hpp"
 #include "name-dialog.hpp"
 #include "utility.hpp"
 
+namespace advss {
+
 static QMetaObject::Connection addPulse;
 SceneGroupEditWidget *typeEdit = nullptr;
 
@@ -487,9 +490,9 @@ void SwitcherData::loadSceneGroups(obs_data_t *obj)
 	obs_data_array_release(sceneGroupArray);
 }
 
-void AdvSceneSwitcher::setupSceneGroupTab()
+void AdvSceneSwitcher::SetupSceneGroupTab()
 {
-	populateSceneSelection(ui->sceneGroupSceneSelection);
+	PopulateSceneSelection(ui->sceneGroupSceneSelection);
 
 	for (auto &sg : switcher->sceneGroups) {
 		QString text = QString::fromStdString(sg.name);
@@ -538,7 +541,7 @@ SceneGroupEditWidget::SceneGroupEditWidget()
 
 	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
 		{"{{type}}", type}};
-	placeWidgets(
+	PlaceWidgets(
 		obs_module_text("AdvSceneSwitcher.sceneGroupTab.edit.type"),
 		typeLayout, widgetPlaceholders);
 
@@ -555,7 +558,7 @@ SceneGroupEditWidget::SceneGroupEditWidget()
 	countLayout->setContentsMargins(0, 0, 0, 0);
 
 	widgetPlaceholders = {{"{{count}}", count}};
-	placeWidgets(
+	PlaceWidgets(
 		obs_module_text("AdvSceneSwitcher.sceneGroupTab.edit.count"),
 		countLayout, widgetPlaceholders);
 
@@ -573,7 +576,7 @@ SceneGroupEditWidget::SceneGroupEditWidget()
 	timeLayout->setContentsMargins(0, 0, 0, 0);
 
 	widgetPlaceholders = {{"{{time}}", time}};
-	placeWidgets(
+	PlaceWidgets(
 		obs_module_text("AdvSceneSwitcher.sceneGroupTab.edit.time"),
 		timeLayout, widgetPlaceholders);
 
@@ -705,3 +708,5 @@ SceneGroup *GetSceneGroupByQString(const QString &name)
 {
 	return GetSceneGroupByName(name.toUtf8().constData());
 }
+
+} // namespace advss

src/legacy/scene-group.hpp

@@ -10,6 +10,8 @@
 #include <QCheckBox>
 #include <obs.hpp>
 
+namespace advss {
+
 auto constexpr invalid_scene_group_name = "invalid-scene-group";
 
 enum class AdvanceCondition {
@@ -85,3 +87,5 @@ private:
 
 SceneGroup *GetSceneGroupByName(const char *name);
 SceneGroup *GetSceneGroupByQString(const QString &name);
+
+} // namespace advss

src/legacy/scene-trigger.cpp

@@ -1,7 +1,10 @@
+#include "advanced-scene-switcher.hpp"
+#include "switcher-data.hpp"
+#include "utility.hpp"
+
 #include <thread>
 
-#include "advanced-scene-switcher.hpp"
-#include "utility.hpp"
+namespace advss {
 
 bool SceneTrigger::pause = false;
 static QMetaObject::Connection addPulse;
@@ -349,7 +352,7 @@ void SwitcherData::loadSceneTriggers(obs_data_t *obj)
 	obs_data_array_release(triggerArray);
 }
 
-void AdvSceneSwitcher::setupTriggerTab()
+void AdvSceneSwitcher::SetupTriggerTab()
 {
 	for (auto &s : switcher->sceneTriggers) {
 		QListWidgetItem *item;
@@ -398,7 +401,7 @@ void SceneTrigger::load(obs_data_t *obj)
 
 static inline void populateTriggers(QComboBox *list)
 {
-	addSelectionEntry(
+	AddSelectionEntry(
 		list,
 		obs_module_text(
 			"AdvSceneSwitcher.sceneTriggerTab.sceneTriggerType.none"));
@@ -413,7 +416,7 @@ static inline void populateTriggers(QComboBox *list)
 
 inline void populateActions(QComboBox *list)
 {
-	addSelectionEntry(
+	AddSelectionEntry(
 		list,
 		obs_module_text(
 			"AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.none"));
@@ -468,7 +471,7 @@ SceneTriggerWidget::SceneTriggerWidget(QWidget *parent, SceneTrigger *s)
 
 	populateTriggers(triggers);
 	populateActions(actions);
-	populateAudioSelection(audioSources);
+	PopulateAudioSelection(audioSources);
 
 	if (s) {
 		triggers->setCurrentIndex(static_cast<int>(s->triggerType));
@@ -492,7 +495,7 @@ SceneTriggerWidget::SceneTriggerWidget(QWidget *parent, SceneTrigger *s)
 		{"{{audioSources}}", audioSources},
 		{"{{duration}}", duration},
 		{"{{scenes}}", scenes}};
-	placeWidgets(obs_module_text("AdvSceneSwitcher.sceneTriggerTab.entry"),
+	PlaceWidgets(obs_module_text("AdvSceneSwitcher.sceneTriggerTab.entry"),
 		     mainLayout, widgetPlaceholders);
 	setLayout(mainLayout);
 
@@ -569,3 +572,5 @@ void SceneTriggerWidget::AudioSourceChanged(const QString &text)
 	std::lock_guard<std::mutex> lock(switcher->m);
 	switchData->audioSource = GetWeakSourceByQString(text);
 }
+
+} // namespace advss

src/legacy/scene-trigger.hpp

@@ -10,6 +10,8 @@
 #include "switch-generic.hpp"
 #include "duration-control.hpp"
 
+namespace advss {
+
 enum class sceneTriggerType {
 	NONE = 0,
 	SCENE_ACTIVE = 1,
@@ -82,3 +84,5 @@ private:
 
 	SceneTrigger *switchData;
 };
+
+} // namespace advss

src/legacy/switch-audio.cpp

@@ -1,9 +1,12 @@
-#include <float.h>
-
 #include "advanced-scene-switcher.hpp"
+#include "switcher-data.hpp"
 #include "volume-control.hpp"
 #include "utility.hpp"
 
+#include <float.h>
+
+namespace advss {
+
 bool AudioSwitch::pause = false;
 static QMetaObject::Connection addPulse;
 
@@ -212,7 +215,7 @@ void SwitcherData::loadAudioSwitches(obs_data_t *obj)
 	audioFallback.load(obj);
 }
 
-void AdvSceneSwitcher::setupAudioTab()
+void AdvSceneSwitcher::SetupAudioTab()
 {
 	for (auto &s : switcher->audioSwitches) {
 		QListWidgetItem *item;
@@ -446,7 +449,7 @@ AudioSwitchWidget::AudioSwitchWidget(QWidget *parent, AudioSwitch *s)
 	QWidget::connect(ignoreInactiveSource, SIGNAL(stateChanged(int)), this,
 			 SLOT(IgnoreInactiveChanged(int)));
 
-	populateAudioSelection(audioSources);
+	PopulateAudioSelection(audioSources);
 	populateConditionSelection(condition);
 
 	if (s) {
@@ -467,7 +470,7 @@ AudioSwitchWidget::AudioSwitchWidget(QWidget *parent, AudioSwitch *s)
 		{"{{ignoreInactiveSource}}", ignoreInactiveSource},
 		{"{{scenes}}", scenes},
 		{"{{transitions}}", transitions}};
-	placeWidgets(obs_module_text("AdvSceneSwitcher.audioTab.entry"),
+	PlaceWidgets(obs_module_text("AdvSceneSwitcher.audioTab.entry"),
 		     switchLayout, widgetPlaceholders);
 
 	QVBoxLayout *mainLayout = new QVBoxLayout;
@@ -592,7 +595,7 @@ AudioSwitchFallbackWidget::AudioSwitchFallbackWidget(QWidget *parent,
 		{"{{scenes}}", scenes},
 		{"{{duration}}", duration},
 		{"{{transitions}}", transitions}};
-	placeWidgets(
+	PlaceWidgets(
 		obs_module_text("AdvSceneSwitcher.audioTab.multiMatchfallback"),
 		mainLayout, widgetPlaceholders);
 	setLayout(mainLayout);
@@ -611,3 +614,5 @@ void AudioSwitchFallbackWidget::DurationChanged(const Duration &dur)
 	std::lock_guard<std::mutex> lock(switcher->m);
 	switchData->duration = dur;
 }
+
+} // namespace advss

src/legacy/switch-audio.hpp

@@ -13,6 +13,8 @@
 #include "duration-control.hpp"
 #include "volume-control.hpp"
 
+namespace advss {
+
 constexpr auto audio_func = 8;
 
 typedef enum {
@@ -103,3 +105,5 @@ private:
 
 	AudioSwitchFallback *switchData;
 };
+
+} // namespace advss

src/legacy/switch-executable.cpp

@@ -1,6 +1,10 @@
 #include "advanced-scene-switcher.hpp"
+#include "switcher-data.hpp"
+#include "platform-funcs.hpp"
 #include "utility.hpp"
 
+namespace advss {
+
 bool ExecutableSwitch::pause = false;
 static QMetaObject::Connection addPulse;
 
@@ -99,7 +103,7 @@ bool SwitcherData::checkExeSwitch(OBSWeakSource &scene,
 		bool equals = runningProcesses.contains(s.exe);
 		bool matches = (runningProcesses.indexOf(
 					QRegularExpression(s.exe)) != -1);
-		bool focus = (!s.inFocus || isInFocus(s.exe));
+		bool focus = (!s.inFocus || IsInFocus(s.exe));
 
 		// True if current window is ignored AND switch equals OR matches last window
 		bool ignore =
@@ -156,7 +160,7 @@ void SwitcherData::loadExecutableSwitches(obs_data_t *obj)
 	obs_data_array_release(executableArray);
 }
 
-void AdvSceneSwitcher::setupExecutableTab()
+void AdvSceneSwitcher::SetupExecutableTab()
 {
 	for (auto &s : switcher->executableSwitches) {
 		QListWidgetItem *item;
@@ -208,7 +212,7 @@ ExecutableSwitchWidget::ExecutableSwitchWidget(QWidget *parent,
 	QWidget::connect(requiresFocus, SIGNAL(stateChanged(int)), this,
 			 SLOT(FocusChanged(int)));
 
-	populateProcessSelection(processes);
+	PopulateProcessSelection(processes);
 
 	processes->setEditable(true);
 	processes->setMaxVisibleItems(20);
@@ -224,7 +228,7 @@ ExecutableSwitchWidget::ExecutableSwitchWidget(QWidget *parent,
 		{"{{requiresFocus}}", requiresFocus},
 		{"{{scenes}}", scenes},
 		{"{{transitions}}", transitions}};
-	placeWidgets(obs_module_text("AdvSceneSwitcher.executableTab.entry"),
+	PlaceWidgets(obs_module_text("AdvSceneSwitcher.executableTab.entry"),
 		     mainLayout, widgetPlaceholders);
 	setLayout(mainLayout);
 
@@ -272,3 +276,5 @@ void ExecutableSwitchWidget::FocusChanged(int state)
 	std::lock_guard<std::mutex> lock(switcher->m);
 	switchData->inFocus = state;
 }
+
+} // namespace advss

src/legacy/switch-executable.hpp

@@ -9,6 +9,8 @@
 #include <QCheckBox>
 #include "switch-generic.hpp"
 
+namespace advss {
+
 constexpr auto exe_func = 3;
 
 struct ExecutableSwitch : SceneSwitcherEntry {
@@ -42,3 +44,5 @@ private:
 
 	ExecutableSwitch *switchData;
 };
+
+} // namespace advss

src/legacy/switch-file.cpp

@@ -1,3 +1,8 @@
+#include "advanced-scene-switcher.hpp"
+#include "switcher-data.hpp"
+#include "curl-helper.hpp"
+#include "utility.hpp"
+
 #include <QtGlobal>
 #include <QFileDialog>
 #include <QTextStream>
@@ -6,9 +11,7 @@
 #include <regex>
 #include <curl/curl.h>
 
-#include "advanced-scene-switcher.hpp"
-#include "curl-helper.hpp"
-#include "utility.hpp"
+namespace advss {
 
 bool FileSwitch::pause = false;
 static QMetaObject::Connection addPulse;
@@ -209,7 +212,7 @@ bool matchFileContent(QString &filedata, FileSwitch &s)
 	}
 
 	QString text = QString::fromStdString(s.text);
-	return compareIgnoringLineEnding(text, filedata);
+	return CompareIgnoringLineEnding(text, filedata);
 }
 
 bool checkRemoteFileContent(FileSwitch &s)
@@ -411,7 +414,7 @@ void SwitcherData::loadFileSwitches(obs_data_t *obj)
 	fileIO.writePath = obs_data_get_string(obj, "writePath");
 }
 
-void AdvSceneSwitcher::setupFileTab()
+void AdvSceneSwitcher::SetupFileTab()
 {
 	ui->remoteFileWarningLabel->setText(
 		obs_module_text("AdvSceneSwitcher.fileTab.remoteFileWarning1") +
@@ -542,11 +545,11 @@ FileSwitchWidget::FileSwitchWidget(QWidget *parent, FileSwitch *s)
 	QHBoxLayout *line1Layout = new QHBoxLayout;
 	QHBoxLayout *line2Layout = new QHBoxLayout;
 	QHBoxLayout *line3Layout = new QHBoxLayout;
-	placeWidgets(obs_module_text("AdvSceneSwitcher.fileTab.entry"),
+	PlaceWidgets(obs_module_text("AdvSceneSwitcher.fileTab.entry"),
 		     line1Layout, widgetPlaceholders);
-	placeWidgets(obs_module_text("AdvSceneSwitcher.fileTab.entry2"),
+	PlaceWidgets(obs_module_text("AdvSceneSwitcher.fileTab.entry2"),
 		     line2Layout, widgetPlaceholders, false);
-	placeWidgets(obs_module_text("AdvSceneSwitcher.fileTab.entry3"),
+	PlaceWidgets(obs_module_text("AdvSceneSwitcher.fileTab.entry3"),
 		     line3Layout, widgetPlaceholders);
 	mainLayout->addLayout(line1Layout);
 	mainLayout->addLayout(line2Layout);
@@ -665,3 +668,5 @@ void FileSwitchWidget::CheckFileContentChanged(int state)
 	std::lock_guard<std::mutex> lock(switcher->m);
 	switchData->onlyMatchIfChanged = state;
 }
+
+} // namespace advss

src/legacy/switch-file.hpp

@@ -8,8 +8,11 @@
 #pragma once
 #include "switch-generic.hpp"
 #include <QPlainTextEdit>
+#include <QDateTime>
 #include <obs-module.h>
 
+namespace advss {
+
 constexpr auto read_file_func = 0;
 
 typedef enum {
@@ -77,3 +80,5 @@ static inline QString MakeFileSwitchName(const QString &scene,
 					 const QString &fileName,
 					 const QString &text, bool useRegex,
 					 bool useTime, bool onlyMatchIfChanged);
+
+} // namespace advss

src/legacy/switch-generic.cpp

@@ -1,6 +1,12 @@
 #include "advanced-scene-switcher.hpp"
+#include "switcher-data.hpp"
 #include "utility.hpp"
 
+constexpr auto previous_scene_name = "Previous Scene";
+constexpr auto current_transition_name = "Current Transition";
+
+namespace advss {
+
 static inline bool SceneGroupValid(SceneGroup *group)
 {
 	if (group) {
@@ -208,9 +214,9 @@ SwitchWidget::SwitchWidget(QWidget *parent, SceneSwitcherEntry *s,
 		SIGNAL(SceneGroupRenamed(const QString &, const QString &)),
 		this, SLOT(SceneGroupRename(const QString &, const QString &)));
 
-	populateSceneSelection(scenes, usePreviousScene, false, false,
+	PopulateSceneSelection(scenes, usePreviousScene, false, false,
 			       addSceneGroup, &switcher->sceneGroups);
-	populateTransitionSelection(transitions, addCurrentTransition);
+	PopulateTransitionSelection(transitions, addCurrentTransition);
 
 	switchData = s;
 	showSwitchData();
@@ -300,3 +306,5 @@ void SwitchWidget::TransitionChanged(const QString &text)
 	switchData->transition = GetWeakTransitionByQString(text);
 	switchData->useCurrentTransition = switchData->transition == nullptr;
 }
+
+} // namespace advss

src/legacy/switch-generic.hpp

@@ -4,6 +4,8 @@
 
 #include "scene-group.hpp"
 
+namespace advss {
+
 enum class SwitchTargetType {
 	Scene,
 	SceneGroup,
@@ -95,3 +97,5 @@ protected:
 
 	SceneSwitcherEntry *switchData;
 };
+
+} // namespace advss

src/legacy/switch-idle.cpp

@@ -1,7 +1,11 @@
+#include "advanced-scene-switcher.hpp"
+#include "switcher-data.hpp"
+#include "platform-funcs.hpp"
+#include "utility.hpp"
+
 #include <regex>
 
-#include "advanced-scene-switcher.hpp"
-#include "utility.hpp"
+namespace advss {
 
 bool IdleData::pause = false;
 IdleWidget *idleWidget = nullptr;
@@ -38,7 +42,7 @@ bool SwitcherData::checkIdleSwitch(OBSWeakSource &scene,
 		}
 	}
 
-	if (!ignoreIdle && secondsSinceLastInput() > idleData.time) {
+	if (!ignoreIdle && SecondsSinceLastInput() > idleData.time) {
 		if (idleData.alreadySwitched) {
 			return false;
 		}
@@ -205,9 +209,9 @@ void SwitcherData::loadIdleSwitches(obs_data_t *obj)
 	idleData.load(obj);
 }
 
-void AdvSceneSwitcher::setupIdleTab()
+void AdvSceneSwitcher::SetupIdleTab()
 {
-	populateWindowSelection(ui->ignoreIdleWindowsWindows);
+	PopulateWindowSelection(ui->ignoreIdleWindowsWindows);
 
 	for (auto &window : switcher->ignoreIdleWindows) {
 		QString text = QString::fromStdString(window);
@@ -267,7 +271,7 @@ IdleWidget::IdleWidget(QWidget *parent, IdleData *s)
 		{"{{duration}}", duration},
 		{"{{scenes}}", scenes},
 		{"{{transitions}}", transitions}};
-	placeWidgets(obs_module_text("AdvSceneSwitcher.idleTab.idleswitch"),
+	PlaceWidgets(obs_module_text("AdvSceneSwitcher.idleTab.idleswitch"),
 		     mainLayout, widgetPlaceholders);
 	setLayout(mainLayout);
 
@@ -285,3 +289,5 @@ void IdleWidget::DurationChanged(int dur)
 	std::lock_guard<std::mutex> lock(switcher->m);
 	switcher->idleData.time = dur;
 }
+
+} // namespace advss

src/legacy/switch-idle.hpp

@@ -8,6 +8,8 @@
 #pragma once
 #include "switch-generic.hpp"
 
+namespace advss {
+
 constexpr auto default_idle_time = 60;
 constexpr auto idle_func = 2;
 
@@ -36,3 +38,5 @@ private:
 
 	IdleData *switchData;
 };
+
+} // namespace advss

src/legacy/switch-media.cpp

@@ -1,6 +1,9 @@
 #include "advanced-scene-switcher.hpp"
+#include "switcher-data.hpp"
 #include "utility.hpp"
 
+namespace advss {
+
 bool MediaSwitch::pause = false;
 static QMetaObject::Connection addPulse;
 
@@ -232,7 +235,7 @@ void SwitcherData::loadMediaSwitches(obs_data_t *obj)
 	obs_data_array_release(mediaArray);
 }
 
-void AdvSceneSwitcher::setupMediaTab()
+void AdvSceneSwitcher::SetupMediaTab()
 {
 	for (auto &s : switcher->mediaSwitches) {
 		QListWidgetItem *item;
@@ -460,7 +463,7 @@ MediaSwitchWidget::MediaSwitchWidget(QWidget *parent, MediaSwitch *s)
 	QWidget::connect(time, SIGNAL(valueChanged(int)), this,
 			 SLOT(TimeChanged(int)));
 
-	populateMediaSelection(mediaSources);
+	PopulateMediaSelection(mediaSources);
 	populateMediaStates(states);
 	populateTimeRestrictions(timeRestrictions);
 
@@ -483,7 +486,7 @@ MediaSwitchWidget::MediaSwitchWidget(QWidget *parent, MediaSwitch *s)
 		{"{{time}}", time},
 		{"{{scenes}}", scenes},
 		{"{{transitions}}", transitions}};
-	placeWidgets(obs_module_text("AdvSceneSwitcher.mediaTab.entry"),
+	PlaceWidgets(obs_module_text("AdvSceneSwitcher.mediaTab.entry"),
 		     mainLayout, widgetPlaceholders);
 	setLayout(mainLayout);
 
@@ -560,3 +563,5 @@ void MediaSwitchWidget::TimeChanged(int time)
 	std::lock_guard<std::mutex> lock(switcher->m);
 	switchData->time = time;
 }
+
+} // namespace advss

src/legacy/switch-media.hpp

@@ -8,6 +8,8 @@
 #pragma once
 #include "switch-generic.hpp"
 
+namespace advss {
+
 constexpr auto media_func = 6;
 
 typedef enum {
@@ -83,3 +85,5 @@ private:
 
 	MediaSwitch *switchData;
 };
+
+} // namespace advss

src/legacy/switch-network.cpp

@@ -7,8 +7,12 @@ Most of this code is based on https://github.com/Palakis/obs-websocket
 #include <QMessageBox>
 
 #include "advanced-scene-switcher.hpp"
+#include "switcher-data.hpp"
+#include "scene-switch-helpers.hpp"
 #include "utility.hpp"
 
+namespace advss {
+
 #define PARAM_SERVER_ENABLE "ServerEnabled"
 #define PARAM_SERVER_PORT "ServerPort"
 #define PARAM_LOCKTOIPV4 "LockToIPv4"
@@ -124,10 +128,9 @@ WSServer::WSServer() : QObject(nullptr), _connections(), _clMutex()
 	_server.set_reuse_addr(true);
 #endif
 
-	_server.set_open_handler(bind(&WSServer::onOpen, this, ::_1));
-	_server.set_close_handler(bind(&WSServer::onClose, this, ::_1));
-	_server.set_message_handler(
-		bind(&WSServer::onMessage, this, ::_1, ::_2));
+	_server.set_open_handler(bind(&WSServer::onOpen, this, _1));
+	_server.set_close_handler(bind(&WSServer::onClose, this, _1));
+	_server.set_message_handler(bind(&WSServer::onMessage, this, _1, _2));
 }
 
 WSServer::~WSServer()
@@ -221,7 +224,7 @@ void WSServer::stop()
 	blog(LOG_INFO, "server stopped successfully");
 }
 
-void WSServer::sendMessage(sceneSwitchInfo sceneSwitch, bool preview)
+void WSServer::sendMessage(SceneSwitchInfo sceneSwitch, bool preview)
 {
 	if (!sceneSwitch.scene) {
 		return;
@@ -305,9 +308,9 @@ std::string processMessage(std::string payload)
 		       "'";
 	}
 	if (preview) {
-		switchPreviewScene(scene);
+		SwitchPreviewScene(scene);
 	} else {
-		switchScene({scene, transition, duration});
+		SwitchScene({scene, transition, duration});
 	}
 	return ret;
 }
@@ -361,11 +364,10 @@ WSClient::WSClient() : QObject(nullptr)
 	_client.set_reuse_addr(true);
 #endif
 
-	_client.set_open_handler(bind(&WSClient::onOpen, this, ::_1));
-	_client.set_fail_handler(bind(&WSClient::onFail, this, ::_1));
-	_client.set_message_handler(
-		bind(&WSClient::onMessage, this, ::_1, ::_2));
-	_client.set_close_handler(bind(&WSClient::onClose, this, ::_1));
+	_client.set_open_handler(bind(&WSClient::onOpen, this, _1));
+	_client.set_fail_handler(bind(&WSClient::onFail, this, _1));
+	_client.set_message_handler(bind(&WSClient::onMessage, this, _1, _2));
+	_client.set_close_handler(bind(&WSClient::onClose, this, _1));
 }
 
 WSClient::~WSClient()
@@ -501,7 +503,7 @@ void SwitcherData::saveNetworkSwitches(obs_data_t *obj)
 	}
 }
 
-void AdvSceneSwitcher::setupNetworkTab()
+void AdvSceneSwitcher::SetupNetworkTab()
 {
 	ui->serverSettings->setChecked(switcher->networkConfig.ServerEnabled);
 	ui->serverPort->setValue(switcher->networkConfig.ServerPort);
@@ -519,9 +521,9 @@ void AdvSceneSwitcher::setupNetworkTab()
 
 	QTimer *statusTimer = new QTimer(this);
 	connect(statusTimer, SIGNAL(timeout()), this,
-		SLOT(updateClientStatus()));
+		SLOT(UpdateClientStatus()));
 	connect(statusTimer, SIGNAL(timeout()), this,
-		SLOT(updateServerStatus()));
+		SLOT(UpdateServerStatus()));
 	statusTimer->start(500);
 }
 
@@ -572,7 +574,7 @@ void AdvSceneSwitcher::on_serverRestart_clicked()
 			       switcher->networkConfig.LockToIPv4);
 }
 
-void AdvSceneSwitcher::updateServerStatus()
+void AdvSceneSwitcher::UpdateServerStatus()
 {
 	switch (switcher->serverStatus) {
 	case ServerStatus::NOT_RUNNING:
@@ -670,7 +672,7 @@ void AdvSceneSwitcher::on_clientReconnect_clicked()
 	switcher->client.connect(switcher->networkConfig.GetClientUri());
 }
 
-void AdvSceneSwitcher::updateClientStatus()
+void AdvSceneSwitcher::UpdateClientStatus()
 {
 	switch (switcher->clientStatus) {
 	case ClientStatus::DISCONNECTED:
@@ -709,3 +711,5 @@ Compatability::StdFunctionRunnable::StdFunctionRunnable(
 	: cb(std::move(func))
 {
 }
+
+} // namespace advss

src/legacy/switch-network.hpp

@@ -19,11 +19,13 @@ Most of this code is based on https://github.com/Palakis/obs-websocket
 #include <websocketpp/server.hpp>
 #include <websocketpp/client.hpp>
 
+namespace advss {
+
 using websocketpp::connection_hdl;
 typedef websocketpp::server<websocketpp::config::asio> server;
 typedef websocketpp::client<websocketpp::config::asio_client> client;
 
-struct sceneSwitchInfo;
+struct SceneSwitchInfo;
 
 class NetworkConfig {
 public:
@@ -60,7 +62,7 @@ public:
 	virtual ~WSServer();
 	void start(quint16 port, bool lockToIPv4);
 	void stop();
-	void sendMessage(sceneSwitchInfo sceneSwitch, bool preview = false);
+	void sendMessage(SceneSwitchInfo sceneSwitch, bool preview = false);
 	QThreadPool *threadPool() { return &_threadPool; }
 
 private:
@@ -131,3 +133,5 @@ public:
 
 QRunnable *CreateFunctionRunnable(std::function<void()> func);
 }
+
+} // namespace advss

src/legacy/switch-pause.cpp

@@ -1,7 +1,10 @@
+#include "advanced-scene-switcher.hpp"
+#include "switcher-data.hpp"
+#include "utility.hpp"
+
 #include <regex>
 
-#include "advanced-scene-switcher.hpp"
-#include "utility.hpp"
+namespace advss {
 
 static QMetaObject::Connection addPulse;
 
@@ -244,7 +247,7 @@ void SwitcherData::loadPauseSwitches(obs_data_t *obj)
 	obs_data_array_release(pauseArray);
 }
 
-void AdvSceneSwitcher::setupPauseTab()
+void AdvSceneSwitcher::SetupPauseTab()
 {
 	for (auto &s : switcher->pauseEntries) {
 		QListWidgetItem *item;
@@ -309,7 +312,7 @@ PauseEntryWidget::PauseEntryWidget(QWidget *parent, PauseEntry *s)
 
 	populatePauseTypes(pauseTypes);
 	populatePauseTargets(pauseTargets);
-	populateWindowSelection(windows);
+	PopulateWindowSelection(windows);
 
 	windows->setEditable(true);
 	windows->setMaxVisibleItems(20);
@@ -335,7 +338,7 @@ PauseEntryWidget::PauseEntryWidget(QWidget *parent, PauseEntry *s)
 		{"{{pauseTargets}}", pauseTargets},
 		{"{{windows}}", windows}};
 
-	placeWidgets(obs_module_text("AdvSceneSwitcher.pauseTab.pauseEntry"),
+	PlaceWidgets(obs_module_text("AdvSceneSwitcher.pauseTab.pauseEntry"),
 		     mainLayout, widgetPlaceholders);
 	setLayout(mainLayout);
 
@@ -410,3 +413,5 @@ bool PauseEntry::valid()
 {
 	return true;
 }
+
+} // namespace advss

src/legacy/switch-pause.hpp

@@ -8,6 +8,8 @@
 #pragma once
 #include "switch-generic.hpp"
 
+namespace advss {
+
 enum class PauseType {
 	Scene,
 	Window,
@@ -70,3 +72,5 @@ private:
 
 	PauseEntry *switchData;
 };
+
+} // namespace advss

src/legacy/switch-priority.cpp

@@ -1,78 +0,0 @@
-#include <algorithm>
-
-#include "advanced-scene-switcher.hpp"
-
-void AdvSceneSwitcher::on_threadPriority_currentTextChanged(const QString &text)
-{
-	if (loading || ui->threadPriority->count() !=
-			       (int)switcher->threadPriorities.size())
-		return;
-
-	std::lock_guard<std::mutex> lock(switcher->m);
-
-	for (auto p : switcher->threadPriorities) {
-		if (p.name == text.toUtf8().constData()) {
-			switcher->threadPriority = p.value;
-			break;
-		}
-	}
-}
-
-void AdvSceneSwitcher::on_priorityUp_clicked()
-{
-	int currentIndex = ui->priorityList->currentRow();
-	if (currentIndex != -1 && currentIndex != 0) {
-		ui->priorityList->insertItem(
-			currentIndex - 1,
-			ui->priorityList->takeItem(currentIndex));
-		ui->priorityList->setCurrentRow(currentIndex - 1);
-		std::lock_guard<std::mutex> lock(switcher->m);
-
-		iter_swap(switcher->functionNamesByPriority.begin() +
-				  currentIndex,
-			  switcher->functionNamesByPriority.begin() +
-				  currentIndex - 1);
-	}
-	ui->macroPriorityWarning->setVisible(
-		switcher->functionNamesByPriority[0] != macro_func);
-}
-
-void AdvSceneSwitcher::on_priorityDown_clicked()
-{
-	int currentIndex = ui->priorityList->currentRow();
-	if (currentIndex != -1 &&
-	    currentIndex != ui->priorityList->count() - 1) {
-		ui->priorityList->insertItem(
-			currentIndex + 1,
-			ui->priorityList->takeItem(currentIndex));
-		ui->priorityList->setCurrentRow(currentIndex + 1);
-		std::lock_guard<std::mutex> lock(switcher->m);
-
-		iter_swap(switcher->functionNamesByPriority.begin() +
-				  currentIndex,
-			  switcher->functionNamesByPriority.begin() +
-				  currentIndex + 1);
-	}
-	ui->macroPriorityWarning->setVisible(
-		switcher->functionNamesByPriority[0] != macro_func);
-}
-
-bool SwitcherData::prioFuncsValid()
-{
-	auto fNBPCopy = functionNamesByPriority;
-
-	std::sort(fNBPCopy.begin(), fNBPCopy.end());
-	auto it = std::unique(fNBPCopy.begin(), fNBPCopy.end());
-	bool wasUnique = (it == fNBPCopy.end());
-
-	if (!wasUnique) {
-		return false;
-	}
-
-	for (int p : functionNamesByPriority) {
-		if (p < 0 || p > 10) {
-			return false;
-		}
-	}
-	return true;
-}

src/legacy/switch-random.cpp

@@ -1,7 +1,10 @@
+#include "advanced-scene-switcher.hpp"
+#include "switcher-data.hpp"
+#include "utility.hpp"
+
 #include <random>
 
-#include "advanced-scene-switcher.hpp"
-#include "utility.hpp"
+namespace advss {
 
 bool RandomSwitch::pause = false;
 static QMetaObject::Connection addPulse;
@@ -113,7 +116,7 @@ void SwitcherData::loadRandomSwitches(obs_data_t *obj)
 	obs_data_array_release(randomArray);
 }
 
-void AdvSceneSwitcher::setupRandomTab()
+void AdvSceneSwitcher::SetupRandomTab()
 {
 	for (auto &s : switcher->randomSwitches) {
 		QListWidgetItem *item;
@@ -140,7 +143,8 @@ void AdvSceneSwitcher::setupRandomTab()
 		border-radius: 7px; \
 		border-color: rgb(0,0,0,0) \
 		}");
-	if (switcher->switchIfNotMatching != RANDOM_SWITCH) {
+	if (switcher->switchIfNotMatching !=
+	    SwitcherData::NoMatch::RANDOM_SWITCH) {
 		if (!switcher->disableHints) {
 			PulseWidget(ui->randomDisabledWarning, QColor(Qt::red),
 				    QColor(0, 0, 0, 0));
@@ -182,7 +186,7 @@ RandomSwitchWidget::RandomSwitchWidget(QWidget *parent, RandomSwitch *s)
 		{"{{scenes}}", scenes},
 		{"{{transitions}}", transitions},
 		{"{{delay}}", delay}};
-	placeWidgets(obs_module_text("AdvSceneSwitcher.randomTab.entry"),
+	PlaceWidgets(obs_module_text("AdvSceneSwitcher.randomTab.entry"),
 		     mainLayout, widgetPlaceholders);
 	setLayout(mainLayout);
 
@@ -220,3 +224,5 @@ void RandomSwitchWidget::DelayChanged(double d)
 	std::lock_guard<std::mutex> lock(switcher->m);
 	switchData->delay = d;
 }
+
+} // namespace advss

src/legacy/switch-random.hpp

@@ -8,6 +8,8 @@
 #pragma once
 #include "switch-generic.hpp"
 
+namespace advss {
+
 struct RandomSwitch : SceneSwitcherEntry {
 	static bool pause;
 	double delay = 0.0;
@@ -36,3 +38,5 @@ private:
 
 	RandomSwitch *switchData;
 };
+
+} // namespace advss

src/legacy/switch-screen-region.cpp

@@ -1,12 +1,15 @@
+#include "advanced-scene-switcher.hpp"
+#include "switcher-data.hpp"
+#include "utility.hpp"
+
 #include <QTimer>
 
-#include "advanced-scene-switcher.hpp"
-#include "utility.hpp"
+namespace advss {
 
 bool ScreenRegionSwitch::pause = false;
 static QMetaObject::Connection addPulse;
 
-void AdvSceneSwitcher::clearFrames(QListWidget *list)
+void AdvSceneSwitcher::ClearFrames(QListWidget *list)
 {
 	for (int i = 0; i < list->count(); ++i) {
 		ScreenRegionWidget *sw =
@@ -48,7 +51,7 @@ void AdvSceneSwitcher::on_showFrame_clicked()
 		showCurrentFrame(ui->screenRegionSwitches);
 	} else {
 		SetShowFrames();
-		clearFrames(ui->screenRegionSwitches);
+		ClearFrames(ui->screenRegionSwitches);
 	}
 }
 
@@ -59,7 +62,7 @@ void AdvSceneSwitcher::on_screenRegionSwitches_currentRowChanged(int idx)
 	}
 
 	if (switcher->showFrame) {
-		clearFrames(ui->screenRegionSwitches);
+		ClearFrames(ui->screenRegionSwitches);
 		showCurrentFrame(ui->screenRegionSwitches);
 	}
 }
@@ -153,7 +156,7 @@ bool SwitcherData::checkScreenRegionSwitch(OBSWeakSource &scene,
 		return false;
 	}
 
-	std::pair<int, int> cursorPos = getCursorPos();
+	std::pair<int, int> cursorPos = GetCursorPos();
 	int minRegionSize = 99999;
 	bool match = false;
 
@@ -188,7 +191,7 @@ bool SwitcherData::checkScreenRegionSwitch(OBSWeakSource &scene,
 
 void AdvSceneSwitcher::updateScreenRegionCursorPos()
 {
-	std::pair<int, int> position = getCursorPos();
+	std::pair<int, int> position = GetCursorPos();
 	ui->cursorXPosition->setText(QString::number(position.first));
 	ui->cursorYPosition->setText(QString::number(position.second));
 }
@@ -228,7 +231,7 @@ void SwitcherData::loadScreenRegionSwitches(obs_data_t *obj)
 	obs_data_array_release(screenRegionArray);
 }
 
-void AdvSceneSwitcher::setupRegionTab()
+void AdvSceneSwitcher::SetupRegionTab()
 {
 	for (auto &s : switcher->screenRegionSwitches) {
 		QListWidgetItem *item;
@@ -318,7 +321,7 @@ ScreenRegionWidget::ScreenRegionWidget(QWidget *parent, ScreenRegionSwitch *s)
 	QWidget::connect(maxY, SIGNAL(valueChanged(int)), this,
 			 SLOT(MaxYChanged(int)));
 
-	populateSceneSelection(
+	PopulateSceneSelection(
 		excludeScenes, false, false, false, false, nullptr, true,
 		obs_module_text(
 			"AdvSceneSwitcher.screenRegionTab.excludeScenes.None"),
@@ -342,7 +345,7 @@ ScreenRegionWidget::ScreenRegionWidget(QWidget *parent, ScreenRegionSwitch *s)
 		{"{{scenes}}", scenes},
 		{"{{transitions}}", transitions},
 		{"{{excludeScenes}}", excludeScenes}};
-	placeWidgets(obs_module_text("AdvSceneSwitcher.screenRegionTab.entry"),
+	PlaceWidgets(obs_module_text("AdvSceneSwitcher.screenRegionTab.entry"),
 		     mainLayout, widgetPlaceholders);
 	setLayout(mainLayout);
 
@@ -455,3 +458,5 @@ void ScreenRegionWidget::drawFrame()
 					switchData->maxY - switchData->minY);
 	}
 }
+
+} // namespace advss

src/legacy/switch-screen-region.hpp

@@ -9,6 +9,8 @@
 #include <QSpinBox>
 #include "switch-generic.hpp"
 
+namespace advss {
+
 constexpr auto screen_region_func = 4;
 
 struct ScreenRegionSwitch : SceneSwitcherEntry {
@@ -55,3 +57,5 @@ private:
 
 	void drawFrame();
 };
+
+} // namespace advss

src/legacy/switch-sequence.cpp

@@ -1,9 +1,12 @@
+#include "advanced-scene-switcher.hpp"
+#include "switcher-data.hpp"
+#include "utility.hpp"
+
 #include <QFileDialog>
 #include <QTextStream>
 #include <QScrollArea>
 
-#include "advanced-scene-switcher.hpp"
-#include "utility.hpp"
+namespace advss {
 
 constexpr auto max_extend_text_size = 150;
 
@@ -278,7 +281,7 @@ void SwitcherData::loadSceneSequenceSwitches(obs_data_t *obj)
 	obs_data_array_release(sceneSequenceArray);
 }
 
-void AdvSceneSwitcher::setupSequenceTab()
+void AdvSceneSwitcher::SetupSequenceTab()
 {
 	for (auto &s : switcher->sceneSequenceSwitches) {
 		QListWidgetItem *item;
@@ -601,7 +604,7 @@ SequenceWidget::SequenceWidget(QWidget *parent, SceneSequenceSwitch *s,
 	QWidget::connect(reduce, SIGNAL(clicked()), this,
 			 SLOT(ReduceClicked()));
 
-	populateSceneSelection(startScenes);
+	PopulateSceneSelection(startScenes);
 	interruptible->setToolTip(obs_module_text(
 		"AdvSceneSwitcher.sceneSequenceTab.interruptibleHint"));
 
@@ -613,7 +616,7 @@ SequenceWidget::SequenceWidget(QWidget *parent, SceneSequenceSwitch *s,
 			{"{{scenes}}", scenes},
 			{"{{delay}}", delay},
 			{"{{transitions}}", transitions}};
-		placeWidgets(
+		PlaceWidgets(
 			obs_module_text(
 				"AdvSceneSwitcher.sceneSequenceTab.extendEntry"),
 			mainLayout, widgetPlaceholders);
@@ -626,7 +629,7 @@ SequenceWidget::SequenceWidget(QWidget *parent, SceneSequenceSwitch *s,
 			{"{{delay}}", delay},
 			{"{{transitions}}", transitions},
 			{"{{interruptible}}", interruptible}};
-		placeWidgets(obs_module_text(
+		PlaceWidgets(obs_module_text(
 				     "AdvSceneSwitcher.sceneSequenceTab.entry"),
 			     startSequence, widgetPlaceholders);
 
@@ -793,3 +796,5 @@ void SequenceWidget::ReduceClicked()
 		delete item;
 	}
 }
+
+} // namespace advss

src/legacy/switch-sequence.hpp

@@ -11,6 +11,8 @@
 #include "switch-generic.hpp"
 #include "duration-control.hpp"
 
+namespace advss {
+
 constexpr auto round_trip_func = 1;
 
 struct SceneSequenceSwitch : SceneSwitcherEntry {
@@ -82,3 +84,5 @@ protected:
 
 	SceneSequenceSwitch *switchData;
 };
+
+} // namespace advss

src/legacy/switch-time.cpp

@@ -1,6 +1,9 @@
 #include "advanced-scene-switcher.hpp"
+#include "switcher-data.hpp"
 #include "utility.hpp"
 
+namespace advss {
+
 bool TimeSwitch::pause = false;
 static QMetaObject::Connection addPulse;
 
@@ -179,7 +182,7 @@ void SwitcherData::loadTimeSwitches(obs_data_t *obj)
 	obs_data_array_release(timeArray);
 }
 
-void AdvSceneSwitcher::setupTimeTab()
+void AdvSceneSwitcher::SetupTimeTab()
 {
 	for (auto &s : switcher->timeSwitches) {
 		QListWidgetItem *item;
@@ -258,7 +261,7 @@ TimeSwitchWidget::TimeSwitchWidget(QWidget *parent, TimeSwitch *s)
 		{"{{time}}", time},
 		{"{{scenes}}", scenes},
 		{"{{transitions}}", transitions}};
-	placeWidgets(obs_module_text("AdvSceneSwitcher.timeTab.entry"),
+	PlaceWidgets(obs_module_text("AdvSceneSwitcher.timeTab.entry"),
 		     mainLayout, widgetPlaceholders);
 	setLayout(mainLayout);
 
@@ -306,3 +309,5 @@ void TimeSwitchWidget::TimeChanged(const QTime &time)
 	std::lock_guard<std::mutex> lock(switcher->m);
 	switchData->time = time;
 }
+
+} // namespace advss

src/legacy/switch-time.hpp

@@ -10,6 +10,8 @@
 
 #include "switch-generic.hpp"
 
+namespace advss {
+
 constexpr auto time_func = 7;
 
 typedef enum {
@@ -54,3 +56,5 @@ private:
 
 	TimeSwitch *switchData;
 };
+
+} // namespace advss

src/legacy/switch-transitions.cpp

@@ -1,7 +1,10 @@
+#include "advanced-scene-switcher.hpp"
+#include "switcher-data.hpp"
+#include "utility.hpp"
+
 #include <thread>
 
-#include "advanced-scene-switcher.hpp"
-#include "utility.hpp"
+namespace advss {
 
 constexpr auto default_def_transition_dealy = 300;
 bool DefaultSceneTransition::pause = false;
@@ -169,7 +172,7 @@ void SwitcherData::checkDefaultSceneTransitions()
 	}
 }
 
-void AdvSceneSwitcher::defTransitionDelayValueChanged(int value)
+void AdvSceneSwitcher::DefTransitionDelayValueChanged(int value)
 {
 	if (loading) {
 		return;
@@ -179,104 +182,6 @@ void AdvSceneSwitcher::defTransitionDelayValueChanged(int value)
 	DefaultSceneTransition::delay = value;
 }
 
-std::pair<obs_weak_source_t *, int> getNextTransition(obs_weak_source_t *scene1,
-						      obs_weak_source_t *scene2)
-{
-	obs_weak_source_t *ws = nullptr;
-	int duration = 0;
-	if (scene1 && scene2) {
-		for (SceneTransition &t : switcher->sceneTransitions) {
-			if (!t.initialized()) {
-				continue;
-			}
-
-			if (t.scene == scene1 && t.scene2 == scene2) {
-				ws = t.transition;
-				duration = t.duration * 1000;
-				break;
-			}
-		}
-	}
-	return std::make_pair(ws, duration);
-}
-
-void overwriteTransitionOverride(const sceneSwitchInfo &ssi, transitionData &td)
-{
-	obs_source_t *scene = obs_weak_source_get_source(ssi.scene);
-	obs_data_t *data = obs_source_get_private_settings(scene);
-
-	td.name = obs_data_get_string(data, "transition");
-	td.duration = obs_data_get_int(data, "transition_duration");
-
-	std::string name = GetWeakSourceName(ssi.transition);
-
-	obs_data_set_string(data, "transition", name.c_str());
-	obs_data_set_int(data, "transition_duration", ssi.duration);
-
-	obs_data_release(data);
-	obs_source_release(scene);
-}
-
-void restoreTransitionOverride(obs_source_t *scene, const transitionData &td)
-{
-	obs_data_t *data = obs_source_get_private_settings(scene);
-
-	obs_data_set_string(data, "transition", td.name.c_str());
-	obs_data_set_int(data, "transition_duration", td.duration);
-
-	obs_data_release(data);
-}
-
-void setNextTransition(const sceneSwitchInfo &sceneSwitch,
-		       obs_source_t *currentSource, transitionData &td)
-{
-	// Priority:
-	// 1. Transition tab
-	// 2. Individual switcher entry
-	// 3. Current transition settings
-
-	// Transition Tab
-	obs_weak_source_t *currentScene =
-		obs_source_get_weak_source(currentSource);
-	auto tinfo = getNextTransition(currentScene, sceneSwitch.scene);
-	obs_weak_source_release(currentScene);
-
-	OBSWeakSource nextTransition = tinfo.first;
-	int nextTransitionDuration = tinfo.second;
-
-	// Individual switcher entry
-	if (!nextTransition) {
-		nextTransition = sceneSwitch.transition;
-	}
-	if (!nextTransitionDuration) {
-		nextTransitionDuration = sceneSwitch.duration;
-	}
-
-	// Current transition settings
-	if (!nextTransition) {
-		auto ct = obs_frontend_get_current_transition();
-		nextTransition = obs_source_get_weak_source(ct);
-		obs_weak_source_release(nextTransition);
-		obs_source_release(ct);
-	}
-	if (!nextTransitionDuration) {
-		nextTransitionDuration = obs_frontend_get_transition_duration();
-	}
-
-	if (switcher->adjustActiveTransitionType) {
-		obs_frontend_set_transition_duration(nextTransitionDuration);
-		auto t = obs_weak_source_get_source(nextTransition);
-		obs_frontend_set_current_transition(t);
-		obs_source_release(t);
-	}
-
-	if (switcher->transitionOverrideOverride) {
-		overwriteTransitionOverride({sceneSwitch.scene, nextTransition,
-					     nextTransitionDuration},
-					    td);
-	}
-}
-
 void SwitcherData::saveSceneTransitions(obs_data_t *obj)
 {
 	obs_data_array_t *sceneTransitionsArray = obs_data_array_create();
@@ -349,7 +254,7 @@ void SwitcherData::loadSceneTransitions(obs_data_t *obj)
 		obs_data_get_int(obj, "defTransitionDelay");
 }
 
-void AdvSceneSwitcher::setupTransitionsTab()
+void AdvSceneSwitcher::SetupTransitionsTab()
 {
 	for (auto &s : switcher->sceneTransitions) {
 		QListWidgetItem *item;
@@ -397,11 +302,11 @@ void AdvSceneSwitcher::setupTransitionsTab()
 		"AdvSceneSwitcher.transitionTab.defaultTransition.delay.help"));
 
 	QWidget::connect(defTransitionDelay, SIGNAL(valueChanged(int)), this,
-			 SLOT(defTransitionDelayValueChanged(int)));
+			 SLOT(DefTransitionDelayValueChanged(int)));
 
 	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
 		{"{{defTransitionDelay}}", defTransitionDelay}};
-	placeWidgets(
+	PlaceWidgets(
 		obs_module_text(
 			"AdvSceneSwitcher.transitionTab.defaultTransition.delay"),
 		ui->defTransitionDelayLayout, widgetPlaceholders);
@@ -449,7 +354,7 @@ TransitionSwitchWidget::TransitionSwitchWidget(QWidget *parent,
 	QWidget::connect(duration, SIGNAL(valueChanged(double)), this,
 			 SLOT(DurationChanged(double)));
 
-	populateSceneSelection(scenes2);
+	PopulateSceneSelection(scenes2);
 
 	if (s) {
 		scenes2->setCurrentText(GetWeakSourceName(s->scene2).c_str());
@@ -462,7 +367,7 @@ TransitionSwitchWidget::TransitionSwitchWidget(QWidget *parent,
 		{"{{scenes2}}", scenes2},
 		{"{{duration}}", duration},
 		{"{{transitions}}", transitions}};
-	placeWidgets(obs_module_text("AdvSceneSwitcher.transitionTab.entry"),
+	PlaceWidgets(obs_module_text("AdvSceneSwitcher.transitionTab.entry"),
 		     mainLayout, widgetPlaceholders);
 	setLayout(mainLayout);
 
@@ -518,7 +423,7 @@ DefTransitionSwitchWidget::DefTransitionSwitchWidget(QWidget *parent,
 	QHBoxLayout *mainLayout = new QHBoxLayout;
 	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
 		{"{{scenes}}", scenes}, {"{{transitions}}", transitions}};
-	placeWidgets(
+	PlaceWidgets(
 		obs_module_text(
 			"AdvSceneSwitcher.transitionTab.defaultTransitionEntry"),
 		mainLayout, widgetPlaceholders);
@@ -592,3 +497,5 @@ void DefaultSceneTransition::setTransition()
 	t = std::thread(setTransitionDelayed, transition, delay);
 	t.detach();
 }
+
+} // namespace advss

src/legacy/switch-transitions.hpp

@@ -3,6 +3,8 @@
 
 #include "switch-generic.hpp"
 
+namespace advss {
+
 struct SceneTransition : SceneSwitcherEntry {
 	OBSWeakSource scene2 = nullptr;
 	double duration = 0.3;
@@ -77,3 +79,5 @@ public:
 private:
 	DefaultSceneTransition *switchData;
 };
+
+} // namespace advss

src/legacy/switch-video.cpp

@@ -1,10 +1,13 @@
+#include "advanced-scene-switcher.hpp"
+#include "switcher-data.hpp"
+#include "utility.hpp"
+
 #include <QFileDialog>
 #include <QBuffer>
 #include <QToolTip>
 #include <thread>
 
-#include "advanced-scene-switcher.hpp"
-#include "utility.hpp"
+namespace advss {
 
 bool VideoSwitch::pause = false;
 static QMetaObject::Connection addPulse;
@@ -182,7 +185,7 @@ void SwitcherData::loadVideoSwitches(obs_data_t *obj)
 	obs_data_array_release(videoArray);
 }
 
-void AdvSceneSwitcher::setupVideoTab()
+void AdvSceneSwitcher::SetupVideoTab()
 {
 	for (auto &s : switcher->videoSwitches) {
 		QListWidgetItem *item;
@@ -428,7 +431,7 @@ VideoSwitchWidget::VideoSwitchWidget(QWidget *parent, VideoSwitch *s)
 		{"{{ignoreInactiveSource}}", ignoreInactiveSource},
 		{"{{scenes}}", scenes},
 		{"{{transitions}}", transitions}};
-	placeWidgets(obs_module_text("AdvSceneSwitcher.videoTab.entry"),
+	PlaceWidgets(obs_module_text("AdvSceneSwitcher.videoTab.entry"),
 		     switchLayout, widgetPlaceholders);
 
 	QVBoxLayout *mainLayout = new QVBoxLayout;
@@ -577,3 +580,5 @@ void VideoSwitchWidget::IgnoreInactiveChanged(int state)
 	std::lock_guard<std::mutex> lock(switcher->m);
 	switchData->ignoreInactiveSource = state;
 }
+
+} // namespace advss

src/legacy/switch-video.hpp

@@ -11,6 +11,8 @@
 #include "switch-generic.hpp"
 #include "screenshot-helper.hpp"
 
+namespace advss {
+
 constexpr auto video_func = 9;
 
 enum class videoSwitchType {
@@ -80,3 +82,5 @@ private:
 
 	VideoSwitch *switchData;
 };
+
+} // namespace advss

src/legacy/switch-window.cpp

@@ -1,7 +1,11 @@
+#include "advanced-scene-switcher.hpp"
+#include "switcher-data.hpp"
+#include "platform-funcs.hpp"
+#include "utility.hpp"
+
 #include <regex>
 
-#include "advanced-scene-switcher.hpp"
-#include "utility.hpp"
+namespace advss {
 
 bool WindowSwitch::pause = false;
 static QMetaObject::Connection addPulse;
@@ -177,8 +181,8 @@ void checkWindowTitleSwitchDirect(WindowSwitch &s,
 				  OBSWeakSource &transition)
 {
 	bool focus = (!s.focus || s.window == currentWindowTitle);
-	bool fullscreen = (!s.fullscreen || isFullscreen(s.window));
-	bool max = (!s.maximized || isMaximized(s.window));
+	bool fullscreen = (!s.fullscreen || IsFullscreen(s.window));
+	bool max = (!s.maximized || IsMaximized(s.window));
 
 	if (focus && fullscreen && max) {
 		match = true;
@@ -203,8 +207,8 @@ void checkWindowTitleSwitchRegex(WindowSwitch &s,
 		}
 
 		bool focus = (!s.focus || window == currentWindowTitle);
-		bool fullscreen = (!s.fullscreen || isFullscreen(window));
-		bool max = (!s.maximized || isMaximized(window));
+		bool fullscreen = (!s.fullscreen || IsFullscreen(window));
+		bool max = (!s.maximized || IsMaximized(window));
 
 		if (focus && fullscreen && max) {
 			match = true;
@@ -315,7 +319,7 @@ void SwitcherData::loadWindowTitleSwitches(obs_data_t *obj)
 	obs_data_array_release(ignoreWindowsArray);
 }
 
-void AdvSceneSwitcher::setupTitleTab()
+void AdvSceneSwitcher::SetupTitleTab()
 {
 	for (auto &s : switcher->windowSwitches) {
 		QListWidgetItem *item;
@@ -336,7 +340,7 @@ void AdvSceneSwitcher::setupTitleTab()
 		ui->windowHelp->setVisible(false);
 	}
 
-	populateWindowSelection(ui->ignoreWindowsWindows);
+	PopulateWindowSelection(ui->ignoreWindowsWindows);
 
 	for (auto &window : switcher->ignoreWindowsSwitches) {
 		QString text = QString::fromStdString(window);
@@ -394,7 +398,7 @@ WindowSwitchWidget::WindowSwitchWidget(QWidget *parent, WindowSwitch *s)
 	QWidget::connect(focused, SIGNAL(stateChanged(int)), this,
 			 SLOT(FocusChanged(int)));
 
-	populateWindowSelection(windows);
+	PopulateWindowSelection(windows);
 
 	windows->setEditable(true);
 	windows->setMaxVisibleItems(20);
@@ -414,7 +418,7 @@ WindowSwitchWidget::WindowSwitchWidget(QWidget *parent, WindowSwitch *s)
 		{"{{fullscreen}}", fullscreen},
 		{"{{maximized}}", maximized},
 		{"{{focused}}", focused}};
-	placeWidgets(obs_module_text("AdvSceneSwitcher.windowTitleTab.entry"),
+	PlaceWidgets(obs_module_text("AdvSceneSwitcher.windowTitleTab.entry"),
 		     mainLayout, widgetPlaceholders);
 	setLayout(mainLayout);
 
@@ -482,3 +486,5 @@ void WindowSwitchWidget::FocusChanged(int state)
 	std::lock_guard<std::mutex> lock(switcher->m);
 	switchData->focus = state;
 }
+
+} // namespace advss

src/legacy/switch-window.hpp

@@ -8,6 +8,8 @@
 #pragma once
 #include "switch-generic.hpp"
 
+namespace advss {
+
 constexpr auto window_title_func = 5;
 
 struct WindowSwitch : SceneSwitcherEntry {
@@ -47,3 +49,5 @@ private:
 
 	WindowSwitch *switchData;
 };
+
+} // namespace advss

src/linux/advanced-scene-switcher-nix.cpp

@@ -33,6 +33,8 @@
 #include <fstream>
 #include <sstream>
 
+namespace advss {
+
 static Display *xdisplay = 0;
 
 static QLibrary *libXtstHandle = nullptr;
@@ -315,7 +317,7 @@ bool windowStatesAreSet(const std::string &windowTitle,
 	return false;
 }
 
-bool isMaximized(const std::string &title)
+bool IsMaximized(const std::string &title)
 {
 	std::vector<QString> states;
 	states.emplace_back("_NET_WM_STATE_MAXIMIZED_VERT");
@@ -323,13 +325,19 @@ bool isMaximized(const std::string &title)
 	return windowStatesAreSet(title, states);
 }
 
-bool isFullscreen(const std::string &title)
+bool IsFullscreen(const std::string &title)
 {
 	std::vector<QString> states;
 	states.emplace_back("_NET_WM_STATE_FULLSCREEN");
 	return windowStatesAreSet(title, states);
 }
 
+std::optional<std::string> GetTextInWindow(const std::string &window)
+{
+	// Not implemented
+	return {};
+}
+
 #ifdef USE_PROCPS
 void GetProcessList(QStringList &processes)
 {
@@ -428,7 +436,7 @@ void GetForegroundProcessName(std::string &proc)
 	proc = getProcNameFromPid(pid);
 }
 
-bool isInFocus(const QString &executable)
+bool IsInFocus(const QString &executable)
 {
 	std::string current;
 	GetForegroundProcessName(current);
@@ -442,7 +450,7 @@ bool isInFocus(const QString &executable)
 	return (equals || matches);
 }
 
-int secondsSinceLastInput()
+int SecondsSinceLastInput()
 {
 	if (!canGetIdleTime) {
 		return 0;
@@ -659,3 +667,5 @@ void PlatformCleanup()
 	}
 	cleanupDisplay();
 }
+
+} // namespace advss

src/macro-core/macro-action-audio.cpp

@@ -1,7 +1,9 @@
 #include "macro-action-audio.hpp"
-#include "advanced-scene-switcher.hpp"
+#include "switcher-data.hpp"
 #include "utility.hpp"
 
+namespace advss {
+
 constexpr int64_t nsPerMs = 1000000;
 const std::string MacroActionAudio::id = "audio";
 
@@ -344,7 +346,7 @@ MacroActionAudioEdit::MacroActionAudioEdit(
 	sources.sort();
 	_sources->SetSourceNameList(sources);
 	populateFadeTypeSelection(_fadeTypes);
-	populateMonitorTypeSelection(_monitorTypes);
+	PopulateMonitorTypeSelection(_monitorTypes);
 
 	QWidget::connect(_actions, SIGNAL(currentIndexChanged(int)), this,
 			 SLOT(ActionChanged(int)));
@@ -395,10 +397,10 @@ MacroActionAudioEdit::MacroActionAudioEdit(
 		{"{{fadeTypes}}", _fadeTypes},
 	};
 	QHBoxLayout *entryLayout = new QHBoxLayout;
-	placeWidgets(obs_module_text("AdvSceneSwitcher.action.audio.entry"),
+	PlaceWidgets(obs_module_text("AdvSceneSwitcher.action.audio.entry"),
 		     entryLayout, widgetPlaceholders);
 	_fadeTypeLayout = new QHBoxLayout;
-	placeWidgets(
+	PlaceWidgets(
 		obs_module_text("AdvSceneSwitcher.action.audio.fade.duration"),
 		_fadeTypeLayout, widgetPlaceholders);
 
@@ -417,7 +419,7 @@ MacroActionAudioEdit::MacroActionAudioEdit(
 	_loading = false;
 }
 
-bool hasVolumeControl(MacroActionAudio::Action action)
+static bool hasVolumeControl(MacroActionAudio::Action action)
 {
 	return action == MacroActionAudio::Action::SOURCE_VOLUME ||
 	       action == MacroActionAudio::Action::MASTER_VOLUME;
@@ -445,7 +447,7 @@ void MacroActionAudioEdit::SetWidgetVisibility()
 	_fadeTypeLayout->removeWidget(_fadeTypes);
 	_fadeTypeLayout->removeWidget(_duration);
 	_fadeTypeLayout->removeWidget(_rate);
-	clearLayout(_fadeTypeLayout);
+	ClearLayout(_fadeTypeLayout);
 	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
 		{"{{fade}}", _fade},
 		{"{{duration}}", _duration},
@@ -453,12 +455,12 @@ void MacroActionAudioEdit::SetWidgetVisibility()
 		{"{{fadeTypes}}", _fadeTypes},
 	};
 	if (_entryData->_fadeType == MacroActionAudio::FadeType::DURATION) {
-		placeWidgets(
+		PlaceWidgets(
 			obs_module_text(
 				"AdvSceneSwitcher.action.audio.fade.duration"),
 			_fadeTypeLayout, widgetPlaceholders);
 	} else {
-		placeWidgets(obs_module_text(
+		PlaceWidgets(obs_module_text(
 				     "AdvSceneSwitcher.action.audio.fade.rate"),
 			     _fadeTypeLayout, widgetPlaceholders);
 	}
@@ -468,9 +470,9 @@ void MacroActionAudioEdit::SetWidgetVisibility()
 	_rate->setVisible(_entryData->_fadeType ==
 			  MacroActionAudio::FadeType::RATE);
 
-	setLayoutVisible(_fadeTypeLayout,
+	SetLayoutVisible(_fadeTypeLayout,
 			 hasVolumeControl(_entryData->_action));
-	setLayoutVisible(_fadeOptionsLayout,
+	SetLayoutVisible(_fadeOptionsLayout,
 			 hasVolumeControl(_entryData->_action));
 	adjustSize();
 }
@@ -503,7 +505,7 @@ void MacroActionAudioEdit::SourceChanged(const SourceSelection &source)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_audioSource = source;
 	emit HeaderInfoChanged(
 		QString::fromStdString(_entryData->GetShortDesc()));
@@ -515,7 +517,7 @@ void MacroActionAudioEdit::ActionChanged(int idx)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_action = static_cast<MacroActionAudio::Action>(
 		_actions->itemData(idx).toInt());
 	SetWidgetVisibility();
@@ -527,7 +529,7 @@ void MacroActionAudioEdit::SyncOffsetChanged(const NumberVariable<int> &value)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_syncOffset = value;
 }
 
@@ -537,7 +539,7 @@ void MacroActionAudioEdit::MonitorTypeChanged(int value)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_monitorType = static_cast<obs_monitoring_type>(value);
 }
 
@@ -547,7 +549,7 @@ void MacroActionAudioEdit::BalanceChanged(const NumberVariable<double> &value)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_balance = value;
 }
 
@@ -557,7 +559,7 @@ void MacroActionAudioEdit::VolumeChanged(const NumberVariable<int> &value)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_volume = value;
 }
 
@@ -567,7 +569,7 @@ void MacroActionAudioEdit::FadeChanged(int value)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_fade = value;
 	SetWidgetVisibility();
 }
@@ -578,7 +580,7 @@ void MacroActionAudioEdit::DurationChanged(const Duration &dur)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_duration = dur;
 }
 
@@ -588,7 +590,7 @@ void MacroActionAudioEdit::RateChanged(const NumberVariable<double> &value)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_rate = value;
 }
 
@@ -598,7 +600,7 @@ void MacroActionAudioEdit::WaitChanged(int value)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_wait = value;
 }
 
@@ -608,7 +610,7 @@ void MacroActionAudioEdit::AbortActiveFadeChanged(int value)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_abortActiveFade = value;
 }
 
@@ -618,7 +620,9 @@ void MacroActionAudioEdit::FadeTypeChanged(int value)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_fadeType = static_cast<MacroActionAudio::FadeType>(value);
 	SetWidgetVisibility();
 }
+
+} // namespace advss

src/macro-core/macro-action-audio.hpp

@@ -9,6 +9,8 @@
 #include <QCheckBox>
 #include <QHBoxLayout>
 
+namespace advss {
+
 class MacroActionAudio : public MacroAction {
 public:
 	MacroActionAudio(Macro *m) : MacroAction(m) {}
@@ -119,3 +121,5 @@ private:
 
 	bool _loading = true;
 };
+
+} // namespace advss

src/macro-core/macro-action-edit.cpp

@@ -1,9 +1,12 @@
 #include "advanced-scene-switcher.hpp"
+#include "switcher-data.hpp"
 #include "macro-action-edit.hpp"
 #include "macro-action-scene-switch.hpp"
 #include "section.hpp"
 #include "utility.hpp"
 
+namespace advss {
+
 std::map<std::string, MacroActionInfo> &MacroActionFactory::GetMap()
 {
 	static std::map<std::string, MacroActionInfo> _methods;
@@ -154,7 +157,7 @@ std::shared_ptr<MacroSegment> MacroActionEdit::Data()
 
 void AdvSceneSwitcher::AddMacroAction(int idx)
 {
-	auto macro = getSelectedMacro();
+	auto macro = GetSelectedMacro();
 	if (!macro) {
 		return;
 	}
@@ -193,7 +196,7 @@ void AdvSceneSwitcher::AddMacroAction(int idx)
 
 void AdvSceneSwitcher::on_actionAdd_clicked()
 {
-	auto macro = getSelectedMacro();
+	auto macro = GetSelectedMacro();
 	if (!macro) {
 		return;
 	}
@@ -211,7 +214,7 @@ void AdvSceneSwitcher::on_actionAdd_clicked()
 
 void AdvSceneSwitcher::RemoveMacroAction(int idx)
 {
-	auto macro = getSelectedMacro();
+	auto macro = GetSelectedMacro();
 	if (!macro) {
 		return;
 	}
@@ -237,7 +240,7 @@ void AdvSceneSwitcher::RemoveMacroAction(int idx)
 void AdvSceneSwitcher::on_actionRemove_clicked()
 {
 	if (currentActionIdx == -1) {
-		auto macro = getSelectedMacro();
+		auto macro = GetSelectedMacro();
 		if (!macro) {
 			return;
 		}
@@ -289,7 +292,7 @@ void AdvSceneSwitcher::SwapActions(Macro *m, int pos1, int pos2)
 
 void AdvSceneSwitcher::MoveMacroActionUp(int idx)
 {
-	auto macro = getSelectedMacro();
+	auto macro = GetSelectedMacro();
 	if (!macro) {
 		return;
 	}
@@ -304,7 +307,7 @@ void AdvSceneSwitcher::MoveMacroActionUp(int idx)
 
 void AdvSceneSwitcher::MoveMacroActionDown(int idx)
 {
-	auto macro = getSelectedMacro();
+	auto macro = GetSelectedMacro();
 	if (!macro) {
 		return;
 	}
@@ -319,7 +322,7 @@ void AdvSceneSwitcher::MoveMacroActionDown(int idx)
 
 void AdvSceneSwitcher::MacroActionSelectionChanged(int idx)
 {
-	auto macro = getSelectedMacro();
+	auto macro = GetSelectedMacro();
 	if (!macro) {
 		return;
 	}
@@ -339,7 +342,7 @@ void AdvSceneSwitcher::MacroActionSelectionChanged(int idx)
 
 void AdvSceneSwitcher::MacroActionReorder(int to, int from)
 {
-	auto macro = getSelectedMacro();
+	auto macro = GetSelectedMacro();
 	if (!macro) {
 		return;
 	}
@@ -361,3 +364,5 @@ void AdvSceneSwitcher::MacroActionReorder(int to, int from)
 	HighlightAction(to);
 	emit(MacroSegmentOrderChanged());
 }
+
+} // namespace advss

src/macro-core/macro-action-edit.hpp

@@ -4,6 +4,8 @@
 #include <QComboBox>
 #include <memory>
 
+namespace advss {
+
 struct MacroActionInfo {
 	using TCreateMethod = std::shared_ptr<MacroAction> (*)(Macro *m);
 	using TCreateWidgetMethod = QWidget *(*)(QWidget *parent,
@@ -51,3 +53,5 @@ private:
 	std::shared_ptr<MacroAction> *_entryData;
 	bool _loading = true;
 };
+
+} // namespace advss

src/macro-core/macro-action-file.cpp

@@ -1,11 +1,12 @@
 #include "macro-action-file.hpp"
-#include "advanced-scene-switcher.hpp"
 #include "utility.hpp"
 
 #include <QFile>
 #include <QTextStream>
 #include <QFileDialog>
 
+namespace advss {
+
 const std::string MacroActionFile::id = "file";
 
 bool MacroActionFile::_registered = MacroActionFactory::Register(
@@ -106,7 +107,7 @@ MacroActionFileEdit::MacroActionFileEdit(
 		{"{{matchText}}", _text},
 		{"{{actions}}", _actions},
 	};
-	placeWidgets(obs_module_text("AdvSceneSwitcher.action.file.entry"),
+	PlaceWidgets(obs_module_text("AdvSceneSwitcher.action.file.entry"),
 		     entryLayout, widgetPlaceholders);
 
 	QVBoxLayout *mainLayout = new QVBoxLayout;
@@ -139,7 +140,7 @@ void MacroActionFileEdit::PathChanged(const QString &text)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_file = text.toUtf8().constData();
 	emit HeaderInfoChanged(
 		QString::fromStdString(_entryData->GetShortDesc()));
@@ -151,7 +152,7 @@ void MacroActionFileEdit::TextChanged()
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_text = _text->toPlainText().toStdString();
 
 	adjustSize();
@@ -164,6 +165,8 @@ void MacroActionFileEdit::ActionChanged(int value)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_action = static_cast<FileAction>(value);
 }
+
+} // namespace advss

src/macro-core/macro-action-file.hpp

@@ -5,6 +5,8 @@
 
 #include <QSpinBox>
 
+namespace advss {
+
 enum class FileAction {
 	WRITE,
 	APPEND,
@@ -65,3 +67,5 @@ protected:
 private:
 	bool _loading = true;
 };
+
+} // namespace advss

src/macro-core/macro-action-filter.cpp

@@ -1,7 +1,8 @@
 #include "macro-action-filter.hpp"
-#include "advanced-scene-switcher.hpp"
 #include "utility.hpp"
 
+namespace advss {
+
 const std::string MacroActionFilter::id = "filter";
 
 bool MacroActionFilter::_registered = MacroActionFactory::Register(
@@ -18,24 +19,9 @@ const static std::map<MacroActionFilter::Action, std::string> actionTypes = {
 	 "AdvSceneSwitcher.action.filter.type.settings"},
 };
 
-void MacroActionFilter::ResolveVariables()
-{
-	if (_source.GetType() == SourceSelection::Type::SOURCE) {
-		return;
-	}
-
-	std::string name = GetWeakSourceName(_filter);
-	if (!name.empty()) {
-		_filterName = name;
-	}
-	_filter = GetWeakFilterByName(_source.GetSource(), _filterName.c_str());
-}
-
 bool MacroActionFilter::PerformAction()
 {
-	ResolveVariables();
-
-	auto s = obs_weak_source_get_source(_filter);
+	auto s = obs_weak_source_get_source(_filter.GetFilter(_source));
 	switch (_action) {
 	case Action::ENABLE:
 		obs_source_set_enabled(s, true);
@@ -44,7 +30,7 @@ bool MacroActionFilter::PerformAction()
 		obs_source_set_enabled(s, false);
 		break;
 	case Action::SETTINGS:
-		setSourceSettings(s, _settings);
+		SetSourceSettings(s, _settings);
 		break;
 	default:
 		break;
@@ -59,7 +45,7 @@ void MacroActionFilter::LogAction() const
 	if (it != actionTypes.end()) {
 		vblog(LOG_INFO,
 		      "performed action \"%s\" for filter \"%s\" on source \"%s\"",
-		      it->second.c_str(), GetWeakSourceName(_filter).c_str(),
+		      it->second.c_str(), _filter.ToString().c_str(),
 		      _source.ToString(true).c_str());
 	} else {
 		blog(LOG_WARNING, "ignored unknown filter action %d",
@@ -71,7 +57,7 @@ bool MacroActionFilter::Save(obs_data_t *obj) const
 {
 	MacroAction::Save(obj);
 	_source.Save(obj);
-	obs_data_set_string(obj, "filter", _filterName.c_str());
+	_filter.Save(obj, "filter");
 	obs_data_set_int(obj, "action", static_cast<int>(_action));
 	_settings.Save(obj, "settings");
 	return true;
@@ -81,9 +67,7 @@ bool MacroActionFilter::Load(obs_data_t *obj)
 {
 	MacroAction::Load(obj);
 	_source.Load(obj);
-	_filterName = obs_data_get_string(obj, "filter");
-	_filter = GetWeakFilterByQString(_source.GetSource(),
-					 _filterName.c_str());
+	_filter.Load(obj, _source, "filter");
 	_action = static_cast<Action>(obs_data_get_int(obj, "action"));
 	_settings.Load(obj, "settings");
 	return true;
@@ -91,8 +75,8 @@ bool MacroActionFilter::Load(obs_data_t *obj)
 
 std::string MacroActionFilter::GetShortDesc() const
 {
-	if (_filter && !_source.ToString().empty()) {
-		return _source.ToString() + " - " + GetWeakSourceName(_filter);
+	if (!_filter.ToString().empty() && !_source.ToString().empty()) {
+		return _source.ToString() + " - " + _filter.ToString();
 	}
 	return "";
 }
@@ -108,7 +92,7 @@ MacroActionFilterEdit::MacroActionFilterEdit(
 	QWidget *parent, std::shared_ptr<MacroActionFilter> entryData)
 	: QWidget(parent),
 	  _sources(new SourceSelectionWidget(this, QStringList(), true)),
-	  _filters(new QComboBox()),
+	  _filters(new FilterSelectionWidget(this, _sources, true)),
 	  _actions(new QComboBox()),
 	  _getSettings(new QPushButton(obs_module_text(
 		  "AdvSceneSwitcher.action.filter.getSettings"))),
@@ -126,8 +110,9 @@ MacroActionFilterEdit::MacroActionFilterEdit(
 	QWidget::connect(_sources,
 			 SIGNAL(SourceChanged(const SourceSelection &)), this,
 			 SLOT(SourceChanged(const SourceSelection &)));
-	QWidget::connect(_filters, SIGNAL(currentTextChanged(const QString &)),
-			 this, SLOT(FilterChanged(const QString &)));
+	QWidget::connect(_filters,
+			 SIGNAL(FilterChanged(const FilterSelection &)), this,
+			 SLOT(FilterChanged(const FilterSelection &)));
 	QWidget::connect(_getSettings, SIGNAL(clicked()), this,
 			 SLOT(GetSettingsClicked()));
 	QWidget::connect(_settings, SIGNAL(textChanged()), this,
@@ -140,12 +125,13 @@ MacroActionFilterEdit::MacroActionFilterEdit(
 		{"{{actions}}", _actions},         {"{{settings}}", _settings},
 		{"{{getSettings}}", _getSettings},
 	};
-	placeWidgets(obs_module_text("AdvSceneSwitcher.action.filter.entry"),
+	PlaceWidgets(obs_module_text("AdvSceneSwitcher.action.filter.entry"),
 		     entryLayout, widgetPlaceholders);
 
 	QHBoxLayout *buttonLayout = new QHBoxLayout;
 	buttonLayout->addWidget(_getSettings);
 	buttonLayout->addStretch();
+	buttonLayout->setContentsMargins(0, 0, 0, 0);
 
 	QVBoxLayout *mainLayout = new QVBoxLayout;
 	mainLayout->addLayout(entryLayout);
@@ -166,9 +152,7 @@ void MacroActionFilterEdit::UpdateEntryData()
 
 	_actions->setCurrentIndex(static_cast<int>(_entryData->_action));
 	_sources->SetSource(_entryData->_source);
-	populateFilterSelection(_filters, _entryData->_source.GetSource());
-	_filters->setCurrentText(
-		GetWeakSourceName(_entryData->_filter).c_str());
+	_filters->SetFilter(_entryData->_source, _entryData->_filter);
 	_settings->setPlainText(_entryData->_settings);
 	SetWidgetVisibility(_entryData->_action ==
 			    MacroActionFilter::Action::SETTINGS);
@@ -182,25 +166,19 @@ void MacroActionFilterEdit::SourceChanged(const SourceSelection &source)
 	if (_loading || !_entryData) {
 		return;
 	}
-	{
-		std::lock_guard<std::mutex> lock(switcher->m);
-		_entryData->_source = source;
-	}
-	_filters->clear();
-	populateFilterSelection(_filters, _entryData->_source.GetSource());
-	_filters->adjustSize();
+
+	auto lock = LockContext();
+	_entryData->_source = source;
 }
 
-void MacroActionFilterEdit::FilterChanged(const QString &text)
+void MacroActionFilterEdit::FilterChanged(const FilterSelection &filter)
 {
 	if (_loading || !_entryData) {
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
-	_entryData->_filterName = text.toStdString();
-	_entryData->_filter =
-		GetWeakFilterByQString(_entryData->_source.GetSource(), text);
+	auto lock = LockContext();
+	_entryData->_filter = filter;
 	emit HeaderInfoChanged(
 		QString::fromStdString(_entryData->GetShortDesc()));
 }
@@ -211,7 +189,7 @@ void MacroActionFilterEdit::ActionChanged(int value)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_action = static_cast<MacroActionFilter::Action>(value);
 	SetWidgetVisibility(_entryData->_action ==
 			    MacroActionFilter::Action::SETTINGS);
@@ -219,13 +197,13 @@ void MacroActionFilterEdit::ActionChanged(int value)
 
 void MacroActionFilterEdit::GetSettingsClicked()
 {
-	if (_loading || !_entryData || !_entryData->_source.GetSource() ||
-	    !_entryData->_filter) {
+	if (_loading || !_entryData ||
+	    !_entryData->_filter.GetFilter(_entryData->_source)) {
 		return;
 	}
 
-	_settings->setPlainText(
-		formatJsonString(getSourceSettings(_entryData->_filter)));
+	_settings->setPlainText(FormatJsonString(GetSourceSettings(
+		_entryData->_filter.GetFilter(_entryData->_source))));
 }
 
 void MacroActionFilterEdit::SettingsChanged()
@@ -234,7 +212,7 @@ void MacroActionFilterEdit::SettingsChanged()
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_settings = _settings->toPlainText().toStdString();
 
 	adjustSize();
@@ -246,4 +224,7 @@ void MacroActionFilterEdit::SetWidgetVisibility(bool showSettings)
 	_settings->setVisible(showSettings);
 	_getSettings->setVisible(showSettings);
 	adjustSize();
+	updateGeometry();
 }
+
+} // namespace advss

src/macro-core/macro-action-filter.hpp

@@ -2,11 +2,14 @@
 #include "macro-action-edit.hpp"
 #include "variable-text-edit.hpp"
 #include "source-selection.hpp"
+#include "filter-selection.hpp"
 
 #include <QComboBox>
 #include <QSpinBox>
 #include <QPushButton>
 
+namespace advss {
+
 class MacroActionFilter : public MacroAction {
 public:
 	MacroActionFilter(Macro *m) : MacroAction(m) {}
@@ -28,18 +31,13 @@ public:
 	};
 
 	SourceSelection _source;
-	OBSWeakSource _filter;
+	FilterSelection _filter;
 	Action _action = Action::ENABLE;
 	StringVariable _settings = "";
 
 private:
-	void ResolveVariables();
-	std::string _filterName = "";
-
 	static bool _registered;
 	static const std::string id;
-
-	friend class MacroActionFilterEdit;
 };
 
 class MacroActionFilterEdit : public QWidget {
@@ -60,7 +58,7 @@ public:
 
 private slots:
 	void SourceChanged(const SourceSelection &);
-	void FilterChanged(const QString &);
+	void FilterChanged(const FilterSelection &);
 	void ActionChanged(int value);
 	void GetSettingsClicked();
 	void SettingsChanged();
@@ -69,7 +67,7 @@ signals:
 
 protected:
 	SourceSelectionWidget *_sources;
-	QComboBox *_filters;
+	FilterSelectionWidget *_filters;
 	QComboBox *_actions;
 	QPushButton *_getSettings;
 	VariableTextEdit *_settings;
@@ -79,3 +77,5 @@ private:
 	void SetWidgetVisibility(bool);
 	bool _loading = true;
 };
+
+} // namespace advss

src/macro-core/macro-action-hotkey.cpp

@@ -1,8 +1,11 @@
 #include "macro-action-hotkey.hpp"
-#include "advanced-scene-switcher.hpp"
+#include "platform-funcs.hpp"
 #include "utility.hpp"
+
 #include <obs-interaction.h>
 
+namespace advss {
+
 const std::string MacroActionHotkey::id = "hotkey";
 
 bool MacroActionHotkey::_registered = MacroActionFactory::Register(
@@ -130,7 +133,8 @@ static std::unordered_map<HotkeyType, long> keyTable = {
 	//{HotkeyType::Key_NumpadEnter, ???},
 };
 
-obs_key_combination keysToOBSKeycombo(const std::vector<HotkeyType> &keys)
+static obs_key_combination
+keysToOBSKeycombo(const std::vector<HotkeyType> &keys)
 {
 	obs_key_combination combo{};
 	auto it = keyTable.find(keys.back());
@@ -178,7 +182,7 @@ obs_key_combination keysToOBSKeycombo(const std::vector<HotkeyType> &keys)
 	return combo;
 }
 
-void InjectKeys(const std::vector<HotkeyType> &keys, int duration)
+static void InjectKeys(const std::vector<HotkeyType> &keys, int duration)
 {
 	auto combo = keysToOBSKeycombo(keys);
 	if (obs_key_combination_is_empty(combo)) {
@@ -447,7 +451,7 @@ MacroActionHotkeyEdit::MacroActionHotkeyEdit(
 		{"{{keys}}", _keys},
 		{"{{duration}}", _duration},
 	};
-	placeWidgets(obs_module_text("AdvSceneSwitcher.action.hotkey.entry"),
+	PlaceWidgets(obs_module_text("AdvSceneSwitcher.action.hotkey.entry"),
 		     line1Layout, widgetPlaceholders);
 
 	QHBoxLayout *line2Layout = new QHBoxLayout;
@@ -508,7 +512,7 @@ void MacroActionHotkeyEdit::LShiftChanged(int state)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_leftShift = state;
 }
 
@@ -518,7 +522,7 @@ void MacroActionHotkeyEdit::RShiftChanged(int state)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_rightShift = state;
 }
 
@@ -528,7 +532,7 @@ void MacroActionHotkeyEdit::LCtrlChanged(int state)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_leftCtrl = state;
 }
 
@@ -538,7 +542,7 @@ void MacroActionHotkeyEdit::RCtrlChanged(int state)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_rightCtrl = state;
 }
 
@@ -548,7 +552,7 @@ void MacroActionHotkeyEdit::LAltChanged(int state)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_leftAlt = state;
 }
 
@@ -558,7 +562,7 @@ void MacroActionHotkeyEdit::RAltChanged(int state)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_rightAlt = state;
 }
 
@@ -568,7 +572,7 @@ void MacroActionHotkeyEdit::LMetaChanged(int state)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_leftMeta = state;
 }
 
@@ -578,7 +582,7 @@ void MacroActionHotkeyEdit::RMetaChanged(int state)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_rightMeta = state;
 }
 
@@ -588,7 +592,7 @@ void MacroActionHotkeyEdit::DurationChanged(const Duration &dur)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_duration = dur;
 }
 
@@ -598,7 +602,7 @@ void MacroActionHotkeyEdit::OnlySendToOBSChanged(int state)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_onlySendToObs = state;
 	SetWarningVisibility();
 }
@@ -609,6 +613,8 @@ void MacroActionHotkeyEdit::KeyChanged(int key)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_key = static_cast<HotkeyType>(key);
 }
+
+} // namespace advss

src/macro-core/macro-action-hotkey.hpp

@@ -8,6 +8,8 @@
 #include <QSpinBox>
 #include <QHBoxLayout>
 
+namespace advss {
+
 class MacroActionHotkey : public MacroAction {
 public:
 	MacroActionHotkey(Macro *m) : MacroAction(m) {}
@@ -93,3 +95,5 @@ private:
 	QHBoxLayout *_mainLayout;
 	bool _loading = true;
 };
+
+} // namespace advss

src/macro-core/macro-action-http.cpp

@@ -1,8 +1,10 @@
 #include "macro-action-http.hpp"
-#include "advanced-scene-switcher.hpp"
+#include "switcher-data.hpp"
 #include "utility.hpp"
 #include "curl-helper.hpp"
 
+namespace advss {
+
 const std::string MacroActionHttp::id = "http";
 
 bool MacroActionHttp::_registered = MacroActionFactory::Register(
@@ -16,12 +18,12 @@ const static std::map<MacroActionHttp::Method, std::string> methods = {
 	 "AdvSceneSwitcher.action.http.type.post"},
 };
 
-size_t DropCB(void *, size_t size, size_t nmemb, std::string *)
+static size_t DropCB(void *, size_t size, size_t nmemb, std::string *)
 {
 	return size * nmemb;
 }
 
-size_t WriteCB(void *ptr, size_t size, size_t nmemb, std::string *buffer)
+static size_t WriteCB(void *ptr, size_t size, size_t nmemb, std::string *buffer)
 {
 	buffer->append((char *)ptr, nmemb);
 	return size * nmemb;
@@ -176,11 +178,11 @@ MacroActionHttpEdit::MacroActionHttpEdit(
 		{"{{timeout}}", _timeout},
 	};
 	auto *actionLayout = new QHBoxLayout;
-	placeWidgets(
+	PlaceWidgets(
 		obs_module_text("AdvSceneSwitcher.action.http.entry.line1"),
 		actionLayout, widgetPlaceholders);
 	auto *timeoutLayout = new QHBoxLayout;
-	placeWidgets(
+	PlaceWidgets(
 		obs_module_text("AdvSceneSwitcher.action.http.entry.line2"),
 		timeoutLayout, widgetPlaceholders);
 
@@ -222,7 +224,7 @@ void MacroActionHttpEdit::URLChanged()
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_url = _url->text().toStdString();
 	emit(HeaderInfoChanged(_url->text()));
 }
@@ -233,7 +235,7 @@ void MacroActionHttpEdit::MethodChanged(int value)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_method = static_cast<MacroActionHttp::Method>(value);
 	SetWidgetVisibility();
 }
@@ -244,7 +246,7 @@ void MacroActionHttpEdit::TimeoutChanged(const Duration &dur)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_timeout = dur;
 }
 
@@ -254,7 +256,7 @@ void MacroActionHttpEdit::SetHeadersChanged(int value)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_setHeaders = value;
 	SetWidgetVisibility();
 }
@@ -265,7 +267,7 @@ void MacroActionHttpEdit::HeadersChanged(const StringList &headers)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_headers = headers;
 	adjustSize();
 	updateGeometry();
@@ -274,7 +276,7 @@ void MacroActionHttpEdit::HeadersChanged(const StringList &headers)
 void MacroActionHttpEdit::SetWidgetVisibility()
 {
 	_data->setVisible(_entryData->_method == MacroActionHttp::Method::POST);
-	setLayoutVisible(_headerListLayout, _entryData->_setHeaders);
+	SetLayoutVisible(_headerListLayout, _entryData->_setHeaders);
 
 	adjustSize();
 	updateGeometry();
@@ -286,9 +288,11 @@ void MacroActionHttpEdit::DataChanged()
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_data = _data->toPlainText().toUtf8().constData();
 
 	adjustSize();
 	updateGeometry();
 }
+
+} // namespace advss

src/macro-core/macro-action-http.hpp

@@ -9,6 +9,8 @@
 #include <QComboBox>
 #include <QCheckBox>
 
+namespace advss {
+
 class MacroActionHttp : public MacroAction {
 public:
 	MacroActionHttp(Macro *m) : MacroAction(m, true) {}
@@ -85,3 +87,5 @@ private:
 	DurationSelection *_timeout;
 	bool _loading = true;
 };
+
+} // namespace advss

src/macro-core/macro-action-macro.cpp

@@ -1,7 +1,9 @@
 #include "macro-action-macro.hpp"
-#include "advanced-scene-switcher.hpp"
+#include "macro.hpp"
 #include "utility.hpp"
 
+namespace advss {
+
 const std::string MacroActionMacro::id = "macro";
 
 bool MacroActionMacro::_registered = MacroActionFactory::Register(
@@ -127,7 +129,7 @@ MacroActionMacroEdit::MacroActionMacroEdit(
 		{"{{actions}}", _actions},
 		{"{{macros}}", _macros},
 	};
-	placeWidgets(obs_module_text("AdvSceneSwitcher.action.macro.entry"),
+	PlaceWidgets(obs_module_text("AdvSceneSwitcher.action.macro.entry"),
 		     mainLayout, widgetPlaceholders);
 	setLayout(mainLayout);
 
@@ -155,7 +157,7 @@ void MacroActionMacroEdit::MacroChanged(const QString &text)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_macro = text;
 	emit HeaderInfoChanged(
 		QString::fromStdString(_entryData->GetShortDesc()));
@@ -167,7 +169,7 @@ void MacroActionMacroEdit::ActionChanged(int value)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_action = static_cast<PerformMacroAction>(value);
 
 	if (_entryData->_action == PerformMacroAction::RUN ||
@@ -177,3 +179,5 @@ void MacroActionMacroEdit::ActionChanged(int value)
 		_macros->ShowAllMacros();
 	}
 }
+
+} // namespace advss

src/macro-core/macro-action-macro.hpp

@@ -4,6 +4,8 @@
 
 #include <QHBoxLayout>
 
+namespace advss {
+
 enum class PerformMacroAction {
 	PAUSE,
 	UNPAUSE,
@@ -64,3 +66,5 @@ private:
 	QHBoxLayout *_mainLayout;
 	bool _loading = true;
 };
+
+} // namespace advss

src/macro-core/macro-action-media.cpp

@@ -1,7 +1,8 @@
 #include "macro-action-media.hpp"
-#include "advanced-scene-switcher.hpp"
 #include "utility.hpp"
 
+namespace advss {
+
 const std::string MacroActionMedia::id = "media";
 
 bool MacroActionMedia::_registered = MacroActionFactory::Register(
@@ -125,7 +126,7 @@ MacroActionMediaEdit::MacroActionMediaEdit(
 		{"{{actions}}", _actions},
 		{"{{duration}}", _seek},
 	};
-	placeWidgets(obs_module_text("AdvSceneSwitcher.action.media.entry"),
+	PlaceWidgets(obs_module_text("AdvSceneSwitcher.action.media.entry"),
 		     mainLayout, widgetPlaceholders);
 	setLayout(mainLayout);
 
@@ -152,7 +153,7 @@ void MacroActionMediaEdit::SourceChanged(const SourceSelection &source)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_mediaSource = source;
 	emit HeaderInfoChanged(
 		QString::fromStdString(_entryData->GetShortDesc()));
@@ -164,7 +165,7 @@ void MacroActionMediaEdit::ActionChanged(int value)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_action = static_cast<MediaAction>(value);
 	SetWidgetVisibility();
 }
@@ -175,7 +176,7 @@ void MacroActionMediaEdit::DurationChanged(const Duration &dur)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_seek = dur;
 }
 
@@ -187,3 +188,5 @@ void MacroActionMediaEdit::SetWidgetVisibility()
 	_seek->setVisible(_entryData->_action == MediaAction::SEEK);
 	adjustSize();
 }
+
+} // namespace advss

src/macro-core/macro-action-media.hpp

@@ -6,6 +6,8 @@
 #include <QSpinBox>
 #include <QHBoxLayout>
 
+namespace advss {
+
 enum class MediaAction {
 	PLAY,
 	PAUSE,
@@ -74,3 +76,5 @@ private:
 	QHBoxLayout *_mainLayout;
 	bool _loading = true;
 };
+
+} // namespace advss

src/macro-core/macro-action-osc.cpp

@@ -0,0 +1,318 @@
+#include "macro-action-osc.hpp"
+#include "utility.hpp"
+
+#include <system_error>
+#include <QGroupBox>
+
+namespace advss {
+
+const std::string MacroActionOSC::id = "osc";
+
+bool MacroActionOSC::_registered = MacroActionFactory::Register(
+	MacroActionOSC::id, {MacroActionOSC::Create, MacroActionOSCEdit::Create,
+			     "AdvSceneSwitcher.action.osc"});
+
+MacroActionOSC::MacroActionOSC(Macro *m)
+	: MacroAction(m),
+	  _ctx(asio::io_context()),
+	  _tcpSocket(asio::ip::tcp::socket(_ctx)),
+	  _udpSocket(asio::ip::udp::socket(_ctx))
+{
+}
+
+void MacroActionOSC::SendOSCTCPMessage(const asio::mutable_buffer &buffer)
+{
+	try {
+		asio::write(_tcpSocket, asio::buffer(buffer));
+	} catch (const std::exception &e) {
+		blog(LOG_WARNING,
+		     "failed to send OSC message \"%s\" via TCP %s %d: %s",
+		     _message.ToString().c_str(), _ip.c_str(), _port.GetValue(),
+		     e.what());
+	}
+}
+
+void MacroActionOSC::SendOSCUDPMessage(const asio::mutable_buffer &buffer)
+{
+	try {
+		_udpSocket.send_to(buffer, _updEndpoint);
+	} catch (const std::exception &e) {
+		blog(LOG_WARNING,
+		     "failed to send OSC message \"%s\" via UDP %s %d: %s",
+		     _message.ToString().c_str(), _ip.c_str(), _port.GetValue(),
+		     e.what());
+	}
+}
+
+void MacroActionOSC::UDPReconnect()
+{
+	asio::error_code ec;
+	asio::ip::udp::resolver resolver(_ctx);
+	auto endpoints = resolver.resolve(asio::ip::udp::v4(), _ip.c_str(),
+					  std::to_string(_port.GetValue()), ec);
+	if (ec) {
+		endpoints = resolver.resolve(asio::ip::udp::v6(), _ip.c_str(),
+					     std::to_string(_port.GetValue()),
+					     ec);
+	}
+	if (ec) {
+		blog(LOG_WARNING, "failed to get IP for \"%s\": %s",
+		     _ip.c_str(), ec.message().c_str());
+		return;
+	}
+
+	try {
+		_updEndpoint = endpoints.begin()->endpoint();
+		_udpSocket = asio::ip::udp::socket(_ctx);
+		_udpSocket.open(endpoints.begin()->endpoint().protocol());
+	} catch (const std::exception &e) {
+		blog(LOG_WARNING, "failed to connect to UDP %s %d: %s",
+		     _ip.c_str(), _port.GetValue(), e.what());
+	}
+}
+
+void MacroActionOSC::TCPReconnect()
+{
+	asio::error_code ec;
+	asio::ip::tcp::resolver resolver(_ctx);
+	auto endpoints = resolver.resolve(asio::ip::tcp::v4(), _ip.c_str(),
+					  std::to_string(_port.GetValue()), ec);
+	if (ec) {
+		endpoints = resolver.resolve(asio::ip::tcp::v6(), _ip.c_str(),
+					     std::to_string(_port.GetValue()),
+					     ec);
+	}
+	if (ec) {
+		blog(LOG_WARNING, "failed to get IP for \"%s\": %s",
+		     _ip.c_str(), ec.message().c_str());
+		return;
+	}
+	try {
+		_tcpSocket = asio::ip::tcp::socket(_ctx);
+		_tcpSocket.connect(endpoints.begin()->endpoint());
+	} catch (const std::exception &e) {
+		blog(LOG_WARNING, "failed to connect to TCP %s %d: %s",
+		     _ip.c_str(), _port.GetValue(), e.what());
+	}
+}
+
+void MacroActionOSC::CheckReconnect()
+{
+	if (_protocol == Protocol::TCP &&
+	    (_reconnect || !_tcpSocket.is_open())) {
+		TCPReconnect();
+	}
+
+	if (_protocol == Protocol::UDP &&
+	    (_reconnect || !_udpSocket.is_open())) {
+		UDPReconnect();
+	}
+}
+
+bool MacroActionOSC::PerformAction()
+{
+	auto buffer = _message.GetBuffer();
+	if (!buffer.has_value()) {
+		blog(LOG_WARNING, "failed to create or fill OSC buffer!");
+		return true;
+	}
+
+	CheckReconnect();
+
+	if (_protocol == Protocol::TCP &&
+	    (_reconnect || !_tcpSocket.is_open())) {
+		TCPReconnect();
+	}
+
+	if (_protocol == Protocol::UDP &&
+	    (_reconnect || !_udpSocket.is_open())) {
+		UDPReconnect();
+	}
+
+	auto rawMessage = asio::buffer(*buffer);
+
+	switch (_protocol) {
+	case MacroActionOSC::Protocol::TCP:
+		SendOSCTCPMessage(rawMessage);
+		break;
+	case MacroActionOSC::Protocol::UDP:
+		SendOSCUDPMessage(rawMessage);
+		break;
+	default:
+		break;
+	}
+
+	return true;
+}
+
+void MacroActionOSC::LogAction() const
+{
+	vblog(LOG_INFO, "sending OSC message '%s' to %s %s %d",
+	      _message.ToString().c_str(),
+	      _protocol == Protocol::UDP ? "UDP" : "TCP", _ip.c_str(),
+	      _port.GetValue());
+}
+
+bool MacroActionOSC::Save(obs_data_t *obj) const
+{
+	MacroAction::Save(obj);
+	obs_data_set_int(obj, "protocol", static_cast<int>(_protocol));
+	_ip.Save(obj, "ip");
+	_port.Save(obj, "port");
+	_message.Save(obj);
+	return true;
+}
+
+bool MacroActionOSC::Load(obs_data_t *obj)
+{
+	MacroAction::Load(obj);
+	_protocol = static_cast<Protocol>(obs_data_get_int(obj, "protocol"));
+	_ip.Load(obj, "ip");
+	_port.Load(obj, "port");
+	_message.Load(obj);
+	return true;
+}
+
+void MacroActionOSC::SetProtocol(Protocol p)
+{
+	_protocol = p;
+	_reconnect = true;
+}
+
+void MacroActionOSC::SetIP(const std::string &ip)
+{
+	_ip = ip;
+	_reconnect = true;
+}
+
+void MacroActionOSC::SetPortNr(IntVariable port)
+{
+	_port = port;
+	_reconnect = true;
+}
+
+static void populateProtocolSelection(QComboBox *list)
+{
+	list->addItem("TCP");
+	list->addItem("UDP");
+}
+
+MacroActionOSCEdit::MacroActionOSCEdit(
+	QWidget *parent, std::shared_ptr<MacroActionOSC> entryData)
+	: QWidget(parent),
+	  _protocol(new QComboBox(this)),
+	  _ip(new VariableLineEdit(this)),
+	  _port(new VariableSpinBox(this)),
+	  _message(new OSCMessageEdit(this))
+{
+	populateProtocolSelection(_protocol);
+	_port->setMaximum(65535);
+
+	auto networkGroup =
+		new QGroupBox(obs_module_text("AdvSceneSwitcher.osc.network"));
+	auto networkLayout = new QGridLayout;
+	int row = 0;
+	networkLayout->addWidget(
+		new QLabel(obs_module_text(
+			"AdvSceneSwitcher.osc.network.protocol")),
+		row, 0);
+	networkLayout->addWidget(_protocol, row, 1);
+	++row;
+	networkLayout->addWidget(
+		new QLabel(obs_module_text(
+			"AdvSceneSwitcher.osc.network.address")),
+		row, 0);
+	networkLayout->addWidget(_ip, row, 1);
+	++row;
+	networkLayout->addWidget(new QLabel(obs_module_text(
+					 "AdvSceneSwitcher.osc.network.port")),
+				 row, 0);
+	networkLayout->addWidget(_port, row, 1);
+	networkGroup->setLayout(networkLayout);
+
+	auto messageGroup =
+		new QGroupBox(obs_module_text("AdvSceneSwitcher.osc.message"));
+	auto messageLayout = new QHBoxLayout();
+	messageLayout->addWidget(_message);
+	messageGroup->setLayout(messageLayout);
+
+	auto mainLayout = new QVBoxLayout;
+	mainLayout->addWidget(networkGroup);
+	mainLayout->addWidget(messageGroup);
+	setLayout(mainLayout);
+
+	QWidget::connect(_ip, SIGNAL(editingFinished()), this,
+			 SLOT(IpChanged()));
+	QWidget::connect(_protocol, SIGNAL(currentIndexChanged(int)), this,
+			 SLOT(ProtocolChanged(int)));
+	QWidget::connect(
+		_port,
+		SIGNAL(NumberVariableChanged(const NumberVariable<int> &)),
+		this, SLOT(PortChanged(const NumberVariable<int> &)));
+	QWidget::connect(_message, SIGNAL(MessageChanged(const OSCMessage &)),
+			 this, SLOT(MessageChanged(const OSCMessage &)));
+
+	_entryData = entryData;
+	UpdateEntryData();
+	_loading = false;
+}
+
+void MacroActionOSCEdit::UpdateEntryData()
+{
+	if (!_entryData) {
+		return;
+	}
+
+	_protocol->setCurrentIndex(static_cast<int>(_entryData->GetProtocol()));
+	_ip->setText(_entryData->GetIP());
+	_port->SetValue(_entryData->GetPortNr());
+	_message->SetMessage(_entryData->_message);
+
+	adjustSize();
+	updateGeometry();
+}
+
+void MacroActionOSCEdit::IpChanged()
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	auto lock = LockContext();
+	_entryData->SetIP(_ip->text().toStdString());
+}
+
+void MacroActionOSCEdit::ProtocolChanged(int value)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	auto lock = LockContext();
+	_entryData->SetProtocol(static_cast<MacroActionOSC::Protocol>(value));
+}
+
+void MacroActionOSCEdit::PortChanged(const NumberVariable<int> &value)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	auto lock = LockContext();
+	_entryData->SetPortNr(value);
+}
+
+void MacroActionOSCEdit::MessageChanged(const OSCMessage &m)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	auto lock = LockContext();
+	_entryData->_message = m;
+
+	adjustSize();
+	updateGeometry();
+}
+
+} // namespace advss

src/macro-core/macro-action-osc.hpp

@@ -0,0 +1,94 @@
+#pragma once
+#include "macro-action-edit.hpp"
+#include "osc-helpers.hpp"
+
+#include <memory>
+#include <asio.hpp>
+
+namespace advss {
+
+class MacroActionOSC : public MacroAction {
+public:
+	MacroActionOSC(Macro *m);
+	bool PerformAction();
+	void LogAction() const;
+	bool Save(obs_data_t *obj) const;
+	bool Load(obs_data_t *obj);
+	std::string GetId() const { return id; };
+	static std::shared_ptr<MacroAction> Create(Macro *m)
+	{
+		return std::make_shared<MacroActionOSC>(m);
+	}
+
+	enum class Protocol {
+		TCP,
+		UDP,
+	};
+
+	void SetProtocol(Protocol);
+	Protocol GetProtocol() const { return _protocol; }
+	void SetIP(const std::string &);
+	StringVariable GetIP() const { return _ip; }
+	void SetPortNr(IntVariable);
+	IntVariable GetPortNr() { return _port; }
+
+	OSCMessage _message;
+
+private:
+	void SendOSCTCPMessage(const asio::mutable_buffer &);
+	void SendOSCUDPMessage(const asio::mutable_buffer &);
+
+	void CheckReconnect();
+	void TCPReconnect();
+	void UDPReconnect();
+
+	Protocol _protocol = Protocol::UDP;
+	StringVariable _ip = "localhost";
+	IntVariable _port = 12345;
+	bool _reconnect = true;
+
+	asio::io_context _ctx;
+	asio::ip::tcp::socket _tcpSocket;
+	asio::ip::udp::socket _udpSocket;
+	asio::ip::udp::endpoint _updEndpoint;
+
+	static bool _registered;
+	static const std::string id;
+};
+
+class MacroActionOSCEdit : public QWidget {
+	Q_OBJECT
+
+public:
+	MacroActionOSCEdit(QWidget *parent,
+			   std::shared_ptr<MacroActionOSC> entryData = nullptr);
+	void UpdateEntryData();
+	static QWidget *Create(QWidget *parent,
+			       std::shared_ptr<MacroAction> action)
+	{
+		return new MacroActionOSCEdit(
+			parent,
+			std::dynamic_pointer_cast<MacroActionOSC>(action));
+	}
+
+private slots:
+	void IpChanged();
+	void MessageChanged(const OSCMessage &);
+	void ProtocolChanged(int);
+	void PortChanged(const NumberVariable<int> &value);
+
+signals:
+	void HeaderInfoChanged(const QString &);
+
+protected:
+	std::shared_ptr<MacroActionOSC> _entryData;
+
+private:
+	QComboBox *_protocol;
+	VariableLineEdit *_ip;
+	VariableSpinBox *_port;
+	OSCMessageEdit *_message;
+	bool _loading = true;
+};
+
+} // namespace advss

src/macro-core/macro-action-plugin-state.cpp

@@ -1,15 +1,20 @@
 #include "macro-action-plugin-state.hpp"
-#include "advanced-scene-switcher.hpp"
+#include "switcher-data.hpp"
 #include "utility.hpp"
 
 #include <thread>
+#include <QMainWindow>
+
+using namespace std::chrono_literals;
+
+namespace advss {
 
 const std::string MacroActionPluginState::id = "plugin_state";
 
 bool MacroActionPluginState::_registered = MacroActionFactory::Register(
 	MacroActionPluginState::id,
 	{MacroActionPluginState::Create, MacroActionPluginStateEdit::Create,
-	 "AdvSceneSwitcher.action.PluginState"});
+	 "AdvSceneSwitcher.action.pluginState"});
 
 const static std::map<PluginStateAction, std::string> actionTypes = {
 	{PluginStateAction::STOP,
@@ -18,24 +23,26 @@ const static std::map<PluginStateAction, std::string> actionTypes = {
 	 "AdvSceneSwitcher.action.pluginState.type.noMatch"},
 	{PluginStateAction::IMPORT_SETTINGS,
 	 "AdvSceneSwitcher.action.pluginState.type.import"},
+	{PluginStateAction::TERMINATE,
+	 "AdvSceneSwitcher.action.pluginState.type.terminate"},
 };
 
-const static std::map<NoMatch, std::string> noMatchValues = {
-	{NO_SWITCH,
+const static std::map<SwitcherData::NoMatch, std::string> noMatchValues = {
+	{SwitcherData::NoMatch::NO_SWITCH,
 	 "AdvSceneSwitcher.generalTab.generalBehavior.onNoMet.dontSwitch"},
-	{SWITCH,
+	{SwitcherData::NoMatch::SWITCH,
 	 "AdvSceneSwitcher.generalTab.generalBehavior.onNoMet.switchTo"},
-	{RANDOM_SWITCH,
+	{SwitcherData::NoMatch::RANDOM_SWITCH,
 	 "AdvSceneSwitcher.generalTab.generalBehavior.onNoMet.switchToRandom"},
 };
 
-void stopPlugin()
+static void stopPlugin()
 {
 	std::thread t([]() { switcher->Stop(); });
 	t.detach();
 }
 
-void importSettings(const std::string &path)
+static void importSettings(const std::string &path)
 {
 	if (switcher->settingsWindowOpened) {
 		return;
@@ -44,18 +51,91 @@ void importSettings(const std::string &path)
 	if (!obj) {
 		return;
 	}
-	switcher->loadSettings(obj);
+	switcher->LoadSettings(obj);
 	obs_data_release(obj);
 }
 
-void setNoMatchBehaviour(int value, OBSWeakSource &scene)
+static void setNoMatchBehaviour(int value, OBSWeakSource &scene)
 {
-	switcher->switchIfNotMatching = static_cast<NoMatch>(value);
-	if (switcher->switchIfNotMatching == SWITCH) {
+	switcher->switchIfNotMatching =
+		static_cast<SwitcherData::NoMatch>(value);
+	if (switcher->switchIfNotMatching == SwitcherData::NoMatch::SWITCH) {
 		switcher->nonMatchingScene = scene;
 	}
 }
 
+static void closeOBSWindow()
+{
+	blog(LOG_WARNING, "closing OBS window now!");
+	auto obsWindow =
+		static_cast<QMainWindow *>(obs_frontend_get_main_window());
+	if (obsWindow) {
+		obsWindow->close();
+	} else {
+		blog(LOG_WARNING,
+		     "OBS shutdown was aborted - failed to get QMainWindow");
+	}
+}
+
+static void terminateOBS(void *)
+{
+	static std::mutex mtx;
+	static std::mutex waitMutex;
+	static std::condition_variable cv;
+	static bool abortTerminate;
+	static bool stopWaiting;
+	static std::chrono::high_resolution_clock::time_point
+		lastShutdownAttempt{};
+
+	// Don't allow multiple simultaneous instances of the shutdown dialog
+	std::unique_lock<std::mutex> lock(mtx, std::try_to_lock);
+	if (!lock.owns_lock()) {
+		blog(LOG_INFO,
+		     "OBS shutdown dialog already triggered - ignoring additional request");
+		return;
+	}
+
+	// Prevent the user from locking himself out of controlling OBS by
+	// continuously opening the shutdown dialog
+	auto now = std::chrono::high_resolution_clock::now();
+	if (lastShutdownAttempt + 5s > now) {
+		blog(LOG_INFO,
+		     "OBS shutdown dialog already triggered recently - ignoring request");
+		return;
+	}
+	lastShutdownAttempt = now;
+
+	abortTerminate = false;
+	stopWaiting = false;
+
+	// Give the user a 10s grace period during which the shutdown can be aborted
+	std::thread thread([]() {
+		std::unique_lock<std::mutex> lock(waitMutex);
+		if (cv.wait_for(lock, 10s, [] { return stopWaiting; })) {
+			if (abortTerminate) {
+				blog(LOG_INFO, "OBS shutdown was aborted");
+			} else {
+				closeOBSWindow();
+			}
+		} else {
+			closeOBSWindow();
+		}
+	});
+	thread.detach();
+
+	// Ask the user how to proceed
+	abortTerminate = !DisplayMessage(
+		obs_module_text(
+			"AdvSceneSwitcher.action.pluginState.terminateConfirm"),
+		true, false);
+	stopWaiting = true;
+
+	// This closes OBS immediately if shutdown was confirmed
+	cv.notify_all();
+
+	lock.unlock();
+}
+
 bool MacroActionPluginState::PerformAction()
 {
 	switch (_action) {
@@ -70,6 +150,14 @@ bool MacroActionPluginState::PerformAction()
 		// There is no point in continuing
 		// The settings will be invalid
 		return false;
+	case PluginStateAction::TERMINATE: {
+		std::thread thread([]() {
+			obs_queue_task(OBS_TASK_UI, terminateOBS, nullptr,
+				       false);
+		});
+		thread.detach();
+		break;
+	}
 	default:
 		break;
 	}
@@ -89,6 +177,9 @@ void MacroActionPluginState::LogAction() const
 		vblog(LOG_INFO, "importing settings from %s",
 		      _settingsPath.c_str());
 		break;
+	case PluginStateAction::TERMINATE:
+		vblog(LOG_INFO, "sending terminate signal to OBS in 10s");
+		break;
 	default:
 		blog(LOG_WARNING, "ignored unknown pluginState action %d",
 		     static_cast<int>(_action));
@@ -147,7 +238,7 @@ MacroActionPluginStateEdit::MacroActionPluginStateEdit(
 		"AdvSceneSwitcher.action.pluginState.importWarning"));
 
 	populateActionSelection(_actions);
-	populateSceneSelection(_scenes);
+	PopulateSceneSelection(_scenes);
 
 	QWidget::connect(_actions, SIGNAL(currentIndexChanged(int)), this,
 			 SLOT(ActionChanged(int)));
@@ -166,7 +257,7 @@ MacroActionPluginStateEdit::MacroActionPluginStateEdit(
 		{"{{settings}}", _settings},
 		{"{{settingsWarning}}", _settingsWarning},
 	};
-	placeWidgets(
+	PlaceWidgets(
 		obs_module_text("AdvSceneSwitcher.action.pluginState.entry"),
 		mainLayout, widgetPlaceholders);
 	setLayout(mainLayout);
@@ -196,7 +287,7 @@ void MacroActionPluginStateEdit::ActionChanged(int value)
 	}
 
 	{
-		std::lock_guard<std::mutex> lock(switcher->m);
+		auto lock = LockContext();
 		_entryData->_action = static_cast<PluginStateAction>(value);
 		SetWidgetVisibility();
 	}
@@ -211,7 +302,7 @@ void MacroActionPluginStateEdit::ValueChanged(int value)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_value = value;
 	SetWidgetVisibility();
 }
@@ -222,7 +313,7 @@ void MacroActionPluginStateEdit::SceneChanged(const QString &text)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_scene = GetWeakSourceByQString(text);
 }
 
@@ -232,7 +323,7 @@ void MacroActionPluginStateEdit::PathChanged(const QString &text)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_settingsPath = text.toStdString();
 }
 
@@ -251,7 +342,8 @@ void MacroActionPluginStateEdit::SetWidgetVisibility()
 		break;
 	case PluginStateAction::NO_MATCH_BEHAVIOUR:
 		_values->show();
-		if ((NoMatch)_entryData->_value == SWITCH) {
+		if (static_cast<SwitcherData::NoMatch>(_entryData->_value) ==
+		    SwitcherData::NoMatch::SWITCH) {
 			_scenes->show();
 		}
 		break;
@@ -263,3 +355,5 @@ void MacroActionPluginStateEdit::SetWidgetVisibility()
 		break;
 	}
 }
+
+} // namespace advss

src/macro-core/macro-action-plugin-state.hpp

@@ -5,10 +5,13 @@
 #include <QDoubleSpinBox>
 #include <QLabel>
 
+namespace advss {
+
 enum class PluginStateAction {
 	STOP,
 	NO_MATCH_BEHAVIOUR,
 	IMPORT_SETTINGS,
+	TERMINATE,
 };
 
 class MacroActionPluginState : public MacroAction {
@@ -69,3 +72,5 @@ private:
 	void SetWidgetVisibility();
 	bool _loading = true;
 };
+
+} // namespace advss

src/macro-core/macro-action-profile.cpp

@@ -1,7 +1,8 @@
 #include "macro-action-profile.hpp"
-#include "advanced-scene-switcher.hpp"
 #include "utility.hpp"
 
+namespace advss {
+
 const std::string MacroActionProfile::id = "profile";
 
 bool MacroActionProfile::_registered = MacroActionFactory::Register(
@@ -44,7 +45,7 @@ MacroActionProfileEdit::MacroActionProfileEdit(
 	: QWidget(parent)
 {
 	_profiles = new QComboBox();
-	populateProfileSelection(_profiles);
+	PopulateProfileSelection(_profiles);
 	QWidget::connect(_profiles, SIGNAL(currentTextChanged(const QString &)),
 			 this, SLOT(ProfileChanged(const QString &)));
 
@@ -52,7 +53,7 @@ MacroActionProfileEdit::MacroActionProfileEdit(
 	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
 		{"{{profiles}}", _profiles},
 	};
-	placeWidgets(obs_module_text("AdvSceneSwitcher.action.profile.entry"),
+	PlaceWidgets(obs_module_text("AdvSceneSwitcher.action.profile.entry"),
 		     mainLayout, widgetPlaceholders);
 	setLayout(mainLayout);
 
@@ -76,8 +77,10 @@ void MacroActionProfileEdit::ProfileChanged(const QString &text)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_profile = text.toStdString();
 	emit HeaderInfoChanged(
 		QString::fromStdString(_entryData->GetShortDesc()));
 }
+
+} // namespace advss

src/macro-core/macro-action-profile.hpp

@@ -3,6 +3,8 @@
 
 #include <QComboBox>
 
+namespace advss {
+
 class MacroActionProfile : public MacroAction {
 public:
 	MacroActionProfile(Macro *m) : MacroAction(m) {}
@@ -52,3 +54,5 @@ protected:
 private:
 	bool _loading = true;
 };
+
+} // namespace advss

src/macro-core/macro-action-projector.cpp

@@ -1,9 +1,11 @@
 #include "macro-action-projector.hpp"
-#include "advanced-scene-switcher.hpp"
 #include "utility.hpp"
 
+#include <QGuiApplication>
 #include <QScreen>
 
+namespace advss {
+
 const std::string MacroActionProjector::id = "projector";
 
 bool MacroActionProjector::_registered = MacroActionFactory::Register(
@@ -115,46 +117,6 @@ static inline void populateWindowTypes(QComboBox *list)
 		"AdvSceneSwitcher.action.projector.fullscreen"));
 }
 
-static QStringList getMonitorNames()
-{
-	QStringList monitorNames;
-	QList<QScreen *> screens = QGuiApplication::screens();
-	for (int i = 0; i < screens.size(); i++) {
-		QScreen *screen = screens[i];
-		QRect screenGeometry = screen->geometry();
-		qreal ratio = screen->devicePixelRatio();
-		QString name = "";
-#if defined(__APPLE__) || defined(_WIN32)
-		name = screen->name();
-#else
-		name = screen->model().simplified();
-		if (name.length() > 1 && name.endsWith("-")) {
-			name.chop(1);
-		}
-#endif
-		name = name.simplified();
-
-		if (name.length() == 0) {
-			name = QString("%1 %2")
-				       .arg(obs_module_text(
-					       "AdvSceneSwitcher.action.projector.display"))
-				       .arg(QString::number(i + 1));
-		}
-		QString str =
-			QString("%1: %2x%3 @ %4,%5")
-				.arg(name,
-				     QString::number(screenGeometry.width() *
-						     ratio),
-				     QString::number(screenGeometry.height() *
-						     ratio),
-				     QString::number(screenGeometry.x()),
-				     QString::number(screenGeometry.y()));
-
-		monitorNames << str;
-	}
-	return monitorNames;
-}
-
 MacroActionProjectorEdit::MacroActionProjectorEdit(
 	QWidget *parent, std::shared_ptr<MacroActionProjector> entryData)
 	: QWidget(parent),
@@ -171,7 +133,7 @@ MacroActionProjectorEdit::MacroActionProjectorEdit(
 	auto sources = GetSourceNames();
 	sources.sort();
 	_sources->SetSourceNameList(sources);
-	_monitors->addItems(getMonitorNames());
+	_monitors->addItems(GetMonitorNames());
 
 	QWidget::connect(_windowTypes, SIGNAL(currentIndexChanged(int)), this,
 			 SLOT(WindowTypeChanged(int)));
@@ -191,12 +153,12 @@ MacroActionProjectorEdit::MacroActionProjectorEdit(
 		{"{{monitors}}", _monitors},
 	};
 
-	placeWidgets(obs_module_text(
+	PlaceWidgets(obs_module_text(
 			     "AdvSceneSwitcher.action.projector.entry.monitor"),
 		     _monitorSelection, widgetPlaceholders);
 
 	QHBoxLayout *mainLayout = new QHBoxLayout;
-	placeWidgets(obs_module_text("AdvSceneSwitcher.action.projector.entry"),
+	PlaceWidgets(obs_module_text("AdvSceneSwitcher.action.projector.entry"),
 		     mainLayout, widgetPlaceholders);
 	mainLayout->insertLayout(mainLayout->count() - 1, _monitorSelection);
 	setLayout(mainLayout);
@@ -225,7 +187,7 @@ void MacroActionProjectorEdit::SceneChanged(const SceneSelection &s)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_scene = s;
 }
 
@@ -235,7 +197,7 @@ void MacroActionProjectorEdit::SourceChanged(const SourceSelection &source)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_source = source;
 }
 
@@ -245,7 +207,7 @@ void MacroActionProjectorEdit::MonitorChanged(int value)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_monitor = value;
 }
 
@@ -255,7 +217,7 @@ void MacroActionProjectorEdit::WindowTypeChanged(int)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_fullscreen =
 		_windowTypes->currentText() ==
 		obs_module_text("AdvSceneSwitcher.action.projector.fullscreen");
@@ -268,7 +230,7 @@ void MacroActionProjectorEdit::TypeChanged(int value)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_type = static_cast<MacroActionProjector::Type>(value);
 	SetWidgetVisibility();
 }
@@ -283,8 +245,10 @@ void MacroActionProjectorEdit::SetWidgetVisibility()
 			    MacroActionProjector::Type::SCENE);
 	_sources->setVisible(_entryData->_type ==
 			     MacroActionProjector::Type::SOURCE);
-	setLayoutVisible(_monitorSelection, _entryData->_fullscreen);
+	SetLayoutVisible(_monitorSelection, _entryData->_fullscreen);
 
 	adjustSize();
 	updateGeometry();
 }
+
+} // namespace advss

src/macro-core/macro-action-projector.hpp

@@ -3,6 +3,8 @@
 #include "scene-selection.hpp"
 #include "source-selection.hpp"
 
+namespace advss {
+
 class MacroActionProjector : public MacroAction {
 public:
 	MacroActionProjector(Macro *m) : MacroAction(m) {}
@@ -71,3 +73,5 @@ private:
 	void SetWidgetVisibility();
 	bool _loading = true;
 };
+
+} // namespace advss

src/macro-core/macro-action-random.cpp

@@ -1,9 +1,11 @@
 #include "macro-action-random.hpp"
-#include "advanced-scene-switcher.hpp"
+#include "macro.hpp"
 #include "utility.hpp"
 
 #include <cstdlib>
 
+namespace advss {
+
 const std::string MacroActionRandom::id = "random";
 
 bool MacroActionRandom::_registered = MacroActionFactory::Register(
@@ -100,7 +102,7 @@ MacroActionRandomEdit::MacroActionRandomEdit(
 
 	auto *entryLayout = new QHBoxLayout;
 	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {};
-	placeWidgets(obs_module_text("AdvSceneSwitcher.action.random.entry"),
+	PlaceWidgets(obs_module_text("AdvSceneSwitcher.action.random.entry"),
 		     entryLayout, widgetPlaceholders);
 
 	auto *mainLayout = new QVBoxLayout;
@@ -149,7 +151,7 @@ void MacroActionRandomEdit::Add(const std::string &name)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	MacroRef macro(name);
 	_entryData->_macros.push_back(macro);
 	_allowRepeat->setVisible(ShouldShowAllowRepeat());
@@ -162,7 +164,7 @@ void MacroActionRandomEdit::Remove(int idx)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_macros.erase(std::next(_entryData->_macros.begin(), idx));
 	_allowRepeat->setVisible(ShouldShowAllowRepeat());
 	adjustSize();
@@ -175,7 +177,7 @@ void MacroActionRandomEdit::Replace(int idx, const std::string &name)
 	}
 
 	MacroRef macro(name);
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_macros[idx] = macro;
 	adjustSize();
 }
@@ -186,7 +188,7 @@ void MacroActionRandomEdit::AllowRepeatChanged(int value)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_allowRepeat = value;
 }
 
@@ -203,3 +205,5 @@ bool MacroActionRandomEdit::ShouldShowAllowRepeat()
 	}
 	return false;
 }
+
+} // namespace advss

src/macro-core/macro-action-random.hpp

@@ -6,6 +6,8 @@
 #include <QListWidget>
 #include <QCheckBox>
 
+namespace advss {
+
 class MacroActionRandom : public MultiMacroRefAction {
 public:
 	MacroActionRandom(Macro *m) : MacroAction(m), MultiMacroRefAction(m) {}
@@ -60,3 +62,5 @@ private:
 	QCheckBox *_allowRepeat;
 	bool _loading = true;
 };
+
+} // namespace advss

src/macro-core/macro-action-recording.cpp

@@ -1,7 +1,10 @@
 #include "macro-action-recording.hpp"
-#include "advanced-scene-switcher.hpp"
 #include "utility.hpp"
 
+#include <util/config-file.h>
+
+namespace advss {
+
 const std::string MacroActionRecord::id = "recording";
 
 bool MacroActionRecord::_registered = MacroActionFactory::Register(
@@ -9,45 +12,80 @@ bool MacroActionRecord::_registered = MacroActionFactory::Register(
 	{MacroActionRecord::Create, MacroActionRecordEdit::Create,
 	 "AdvSceneSwitcher.action.recording"});
 
-const static std::map<RecordAction, std::string> actionTypes = {
-	{RecordAction::STOP, "AdvSceneSwitcher.action.recording.type.stop"},
-	{RecordAction::START, "AdvSceneSwitcher.action.recording.type.start"},
-	{RecordAction::PAUSE, "AdvSceneSwitcher.action.recording.type.pause"},
-	{RecordAction::UNPAUSE,
+const static std::map<MacroActionRecord::Action, std::string> actionTypes = {
+	{MacroActionRecord::Action::STOP,
+	 "AdvSceneSwitcher.action.recording.type.stop"},
+	{MacroActionRecord::Action::START,
+	 "AdvSceneSwitcher.action.recording.type.start"},
+	{MacroActionRecord::Action::PAUSE,
+	 "AdvSceneSwitcher.action.recording.type.pause"},
+	{MacroActionRecord::Action::UNPAUSE,
 	 "AdvSceneSwitcher.action.recording.type.unpause"},
-	{RecordAction::SPLIT, "AdvSceneSwitcher.action.recording.type.split"},
+	{MacroActionRecord::Action::SPLIT,
+	 "AdvSceneSwitcher.action.recording.type.split"},
+	{MacroActionRecord::Action::FOLDER,
+	 "AdvSceneSwitcher.action.recording.type.changeOutputFolder"},
+	{MacroActionRecord::Action::FILE_FORMAT,
+	 "AdvSceneSwitcher.action.recording.type.changeOutputFileFormat"},
 };
 
 bool MacroActionRecord::PerformAction()
 {
 	switch (_action) {
-	case RecordAction::STOP:
+	case Action::STOP:
 		if (obs_frontend_recording_active()) {
 			obs_frontend_recording_stop();
 		}
 		break;
-	case RecordAction::START:
+	case Action::START:
 		if (!obs_frontend_recording_active()) {
 			obs_frontend_recording_start();
 		}
 		break;
-	case RecordAction::PAUSE:
+	case Action::PAUSE:
 		if (obs_frontend_recording_active() &&
 		    !obs_frontend_recording_paused()) {
 			obs_frontend_recording_pause(true);
 		}
 		break;
-	case RecordAction::UNPAUSE:
+	case Action::UNPAUSE:
 		if (obs_frontend_recording_active() &&
 		    obs_frontend_recording_paused()) {
 			obs_frontend_recording_pause(false);
 		}
 		break;
 #if LIBOBS_API_VER >= MAKE_SEMANTIC_VERSION(28, 0, 0)
-	case RecordAction::SPLIT:
+	case Action::SPLIT:
 		obs_frontend_recording_split_file();
 		break;
 #endif
+	case Action::FOLDER: {
+		std::string folder = _folder; // Trigger variable resolve
+
+		auto conf = obs_frontend_get_profile_config();
+		config_set_string(conf, "SimpleOutput", "FilePath",
+				  folder.c_str());
+		config_set_string(conf, "AdvOut", "FFFilePath", folder.c_str());
+		config_set_string(conf, "AdvOut", "RecFilePath",
+				  folder.c_str());
+		if (config_save(conf) != CONFIG_SUCCESS) {
+			blog(LOG_WARNING,
+			     "failed to set recoding output folder");
+		}
+		break;
+	}
+	case Action::FILE_FORMAT: {
+		std::string format = _fileFormat; // Trigger variable resolve
+
+		auto conf = obs_frontend_get_profile_config();
+		config_set_string(conf, "Output", "FilenameFormatting",
+				  format.c_str());
+		if (config_save(conf) != CONFIG_SUCCESS) {
+			blog(LOG_WARNING,
+			     "failed to set recoding file format string");
+		}
+		break;
+	}
 	default:
 		break;
 	}
@@ -69,13 +107,17 @@ bool MacroActionRecord::Save(obs_data_t *obj) const
 {
 	MacroAction::Save(obj);
 	obs_data_set_int(obj, "action", static_cast<int>(_action));
+	_folder.Save(obj, "folder");
+	_fileFormat.Save(obj, "format");
 	return true;
 }
 
 bool MacroActionRecord::Load(obs_data_t *obj)
 {
 	MacroAction::Load(obj);
-	_action = static_cast<RecordAction>(obs_data_get_int(obj, "action"));
+	_action = static_cast<Action>(obs_data_get_int(obj, "action"));
+	_folder.Load(obj, "folder");
+	_fileFormat.Load(obj, "format");
 	return true;
 }
 
@@ -93,21 +135,27 @@ MacroActionRecordEdit::MacroActionRecordEdit(
 	  _pauseHint(new QLabel(obs_module_text(
 		  "AdvSceneSwitcher.action.recording.pause.hint"))),
 	  _splitHint(new QLabel(obs_module_text(
-		  "AdvSceneSwitcher.action.recording.split.hint")))
+		  "AdvSceneSwitcher.action.recording.split.hint"))),
+	  _recordFolder(new FileSelection(FileSelection::Type::FOLDER, this)),
+	  _recordFileFormat(new VariableLineEdit(this))
 {
 	populateActionSelection(_actions);
 
 	QWidget::connect(_actions, SIGNAL(currentIndexChanged(int)), this,
 			 SLOT(ActionChanged(int)));
+	QWidget::connect(_recordFolder, SIGNAL(PathChanged(const QString &)),
+			 this, SLOT(FolderChanged(const QString &)));
+	QWidget::connect(_recordFileFormat, SIGNAL(editingFinished()), this,
+			 SLOT(FormatStringChanged()));
 
-	QHBoxLayout *mainLayout = new QHBoxLayout;
-	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
-		{"{{actions}}", _actions},
-		{"{{pauseHint}}", _pauseHint},
-		{"{{splitHint}}", _splitHint},
-	};
-	placeWidgets(obs_module_text("AdvSceneSwitcher.action.recording.entry"),
-		     mainLayout, widgetPlaceholders);
+	auto mainLayout = new QHBoxLayout;
+	PlaceWidgets(obs_module_text("AdvSceneSwitcher.action.recording.entry"),
+		     mainLayout,
+		     {{"{{actions}}", _actions},
+		      {"{{pauseHint}}", _pauseHint},
+		      {"{{splitHint}}", _splitHint},
+		      {"{{recordFolder}}", _recordFolder},
+		      {"{{recordFileFormat}}", _recordFileFormat}});
 	setLayout(mainLayout);
 
 	_entryData = entryData;
@@ -121,18 +169,46 @@ void MacroActionRecordEdit::UpdateEntryData()
 		return;
 	}
 	_actions->setCurrentIndex(static_cast<int>(_entryData->_action));
-	SetLabelVisibility();
+	_recordFolder->SetPath(_entryData->_folder);
+	_recordFileFormat->setText(_entryData->_fileFormat);
+	SetWidgetVisibility();
 }
 
-bool isPauseAction(RecordAction a)
+static bool isPauseAction(MacroActionRecord::Action a)
 {
-	return a == RecordAction::PAUSE || a == RecordAction::UNPAUSE;
+	return a == MacroActionRecord::Action::PAUSE ||
+	       a == MacroActionRecord::Action::UNPAUSE;
 }
 
-void MacroActionRecordEdit::SetLabelVisibility()
+void MacroActionRecordEdit::FolderChanged(const QString &folder)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	auto lock = LockContext();
+	_entryData->_folder = folder.toStdString();
+}
+
+void MacroActionRecordEdit::FormatStringChanged()
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	auto lock = LockContext();
+	_entryData->_fileFormat = _recordFileFormat->text().toStdString();
+}
+
+void MacroActionRecordEdit::SetWidgetVisibility()
 {
 	_pauseHint->setVisible(isPauseAction(_entryData->_action));
-	_splitHint->setVisible(_entryData->_action == RecordAction::SPLIT);
+	_splitHint->setVisible(_entryData->_action ==
+			       MacroActionRecord::Action::SPLIT);
+	_recordFolder->setVisible(_entryData->_action ==
+				  MacroActionRecord::Action::FOLDER);
+	_recordFileFormat->setVisible(_entryData->_action ==
+				      MacroActionRecord::Action::FILE_FORMAT);
 }
 
 void MacroActionRecordEdit::ActionChanged(int value)
@@ -141,7 +217,9 @@ void MacroActionRecordEdit::ActionChanged(int value)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
-	_entryData->_action = static_cast<RecordAction>(value);
-	SetLabelVisibility();
+	auto lock = LockContext();
+	_entryData->_action = static_cast<MacroActionRecord::Action>(value);
+	SetWidgetVisibility();
 }
+
+} // namespace advss

src/macro-core/macro-action-recording.hpp

@@ -1,16 +1,13 @@
 #pragma once
 #include "macro-action-edit.hpp"
+#include "file-selection.hpp"
+#include "variable-line-edit.hpp"
 
+#include <QDir>
 #include <QComboBox>
 #include <QHBoxLayout>
 
-enum class RecordAction {
-	STOP,
-	START,
-	PAUSE,
-	UNPAUSE,
-	SPLIT,
-};
+namespace advss {
 
 class MacroActionRecord : public MacroAction {
 public:
@@ -25,7 +22,19 @@ public:
 		return std::make_shared<MacroActionRecord>(m);
 	}
 
-	RecordAction _action = RecordAction::STOP;
+	enum class Action {
+		STOP,
+		START,
+		PAUSE,
+		UNPAUSE,
+		SPLIT,
+		FOLDER,
+		FILE_FORMAT,
+	};
+	Action _action = Action::STOP;
+
+	StringVariable _folder = QDir::homePath().toStdString() + "/Videos";
+	StringVariable _fileFormat = "%CCYY-%MM-%DD %hh-%mm-%ss";
 
 private:
 	static bool _registered;
@@ -50,16 +59,22 @@ public:
 
 private slots:
 	void ActionChanged(int value);
+	void FolderChanged(const QString &);
+	void FormatStringChanged();
 
 protected:
 	QComboBox *_actions;
 	QLabel *_pauseHint;
 	QLabel *_splitHint;
+	FileSelection *_recordFolder;
+	VariableLineEdit *_recordFileFormat;
 	std::shared_ptr<MacroActionRecord> _entryData;
 
 private:
-	void SetLabelVisibility();
+	void SetWidgetVisibility();
 
 	QHBoxLayout *_mainLayout;
 	bool _loading = true;
 };
+
+} // namespace advss

src/macro-core/macro-action-replay-buffer.cpp

@@ -1,7 +1,8 @@
 #include "macro-action-replay-buffer.hpp"
-#include "advanced-scene-switcher.hpp"
 #include "utility.hpp"
 
+namespace advss {
+
 const std::string MacroActionReplayBuffer::id = "replay_buffer";
 
 bool MacroActionReplayBuffer::_registered = MacroActionFactory::Register(
@@ -89,7 +90,7 @@ MacroActionReplayBufferEdit::MacroActionReplayBufferEdit(
 	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
 		{"{{actions}}", _actions},
 	};
-	placeWidgets(obs_module_text("AdvSceneSwitcher.action.replay.entry"),
+	PlaceWidgets(obs_module_text("AdvSceneSwitcher.action.replay.entry"),
 		     layout, widgetPlaceholders);
 	QVBoxLayout *mainLayout = new QVBoxLayout;
 	mainLayout->addLayout(layout);
@@ -117,9 +118,11 @@ void MacroActionReplayBufferEdit::ActionChanged(int value)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_action = static_cast<ReplayBufferAction>(value);
 	_saveWarning->setVisible(_entryData->_action ==
 				 ReplayBufferAction::SAVE);
 	adjustSize();
 }
+
+} // namespace advss

src/macro-core/macro-action-replay-buffer.hpp

@@ -4,6 +4,8 @@
 
 #include <QHBoxLayout>
 
+namespace advss {
+
 enum class ReplayBufferAction {
 	STOP,
 	START,
@@ -58,3 +60,5 @@ protected:
 private:
 	bool _loading = true;
 };
+
+} // namespace advss

src/macro-core/macro-action-run.cpp

@@ -1,10 +1,11 @@
 #include "macro-action-run.hpp"
-#include "advanced-scene-switcher.hpp"
 #include "utility.hpp"
 
 #include <QProcess>
 #include <QDesktopServices>
 
+namespace advss {
+
 const std::string MacroActionRun::id = "run";
 
 bool MacroActionRun::_registered = MacroActionFactory::Register(
@@ -80,10 +81,12 @@ void MacroActionRunEdit::ProcessConfigChanged(const ProcessConfig &conf)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_procConfig = conf;
 	adjustSize();
 	updateGeometry();
 	emit HeaderInfoChanged(
 		QString::fromStdString(_entryData->GetShortDesc()));
 }
+
+} // namespace advss

src/macro-core/macro-action-run.hpp

@@ -2,6 +2,8 @@
 #include "macro-action-edit.hpp"
 #include "process-config.hpp"
 
+namespace advss {
+
 class MacroActionRun : public MacroAction {
 public:
 	MacroActionRun(Macro *m) : MacroAction(m) {}
@@ -50,3 +52,5 @@ private:
 	ProcessConfigEdit *_procConfig;
 	bool _loading = true;
 };
+
+} // namespace advss

src/macro-core/macro-action-scene-collection.cpp

@@ -1,7 +1,9 @@
 #include "macro-action-scene-collection.hpp"
-#include "advanced-scene-switcher.hpp"
+#include "switcher-data.hpp"
 #include "utility.hpp"
 
+namespace advss {
+
 const std::string MacroActionSceneCollection::id = "scene_collection";
 
 bool MacroActionSceneCollection::_registered = MacroActionFactory::Register(
@@ -60,7 +62,7 @@ void populateSceneCollectionSelection(QComboBox *box)
 	}
 	bfree(sceneCollections);
 	box->model()->sort(0);
-	addSelectionEntry(
+	AddSelectionEntry(
 		box, obs_module_text("AdvSceneSwitcher.selectSceneCollection"),
 		false);
 	box->setCurrentIndex(0);
@@ -80,7 +82,7 @@ MacroActionSceneCollectionEdit::MacroActionSceneCollectionEdit(
 	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
 		{"{{sceneCollections}}", _sceneCollections},
 	};
-	placeWidgets(obs_module_text(
+	PlaceWidgets(obs_module_text(
 			     "AdvSceneSwitcher.action.sceneCollection.entry"),
 		     entryLayout, widgetPlaceholders);
 	QVBoxLayout *mainLayout = new QVBoxLayout;
@@ -110,8 +112,10 @@ void MacroActionSceneCollectionEdit::SceneCollectionChanged(const QString &text)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_sceneCollection = text.toStdString();
 	emit HeaderInfoChanged(
 		QString::fromStdString(_entryData->GetShortDesc()));
 }
+
+} // namespace advss

src/macro-core/macro-action-scene-collection.hpp

@@ -3,6 +3,8 @@
 
 #include <QComboBox>
 
+namespace advss {
+
 class MacroActionSceneCollection : public MacroAction {
 public:
 	MacroActionSceneCollection(Macro *m) : MacroAction(m) {}
@@ -53,3 +55,5 @@ protected:
 private:
 	bool _loading = true;
 };
+
+} // namespace advss

src/macro-core/macro-action-scene-order.cpp

@@ -1,7 +1,8 @@
 #include "macro-action-scene-order.hpp"
-#include "advanced-scene-switcher.hpp"
 #include "utility.hpp"
 
+namespace advss {
+
 const std::string MacroActionSceneOrder::id = "scene_order";
 
 bool MacroActionSceneOrder::_registered = MacroActionFactory::Register(
@@ -22,7 +23,7 @@ const static std::map<SceneOrderAction, std::string> actionTypes = {
 	 "AdvSceneSwitcher.action.sceneOrder.type.movePosition"},
 };
 
-void moveSceneItemsUp(std::vector<obs_scene_item *> &items)
+static void moveSceneItemsUp(std::vector<obs_scene_item *> &items)
 {
 	// In the case of the same source being in two sequential positions
 	// moving the sources up will cause the sources to swap positions due to
@@ -38,7 +39,7 @@ void moveSceneItemsUp(std::vector<obs_scene_item *> &items)
 	}
 }
 
-void moveSceneItemsDown(std::vector<obs_scene_item *> &items)
+static void moveSceneItemsDown(std::vector<obs_scene_item *> &items)
 {
 	for (auto &i : items) {
 		obs_sceneitem_set_order(i, OBS_ORDER_MOVE_DOWN);
@@ -46,7 +47,7 @@ void moveSceneItemsDown(std::vector<obs_scene_item *> &items)
 	}
 }
 
-void moveSceneItemsTop(std::vector<obs_scene_item *> &items)
+static void moveSceneItemsTop(std::vector<obs_scene_item *> &items)
 {
 	for (auto &i : items) {
 		obs_sceneitem_set_order(i, OBS_ORDER_MOVE_TOP);
@@ -54,7 +55,7 @@ void moveSceneItemsTop(std::vector<obs_scene_item *> &items)
 	}
 }
 
-void moveSceneItemsBottom(std::vector<obs_scene_item *> &items)
+static void moveSceneItemsBottom(std::vector<obs_scene_item *> &items)
 {
 	for (auto &i : items) {
 		obs_sceneitem_set_order(i, OBS_ORDER_MOVE_BOTTOM);
@@ -62,7 +63,7 @@ void moveSceneItemsBottom(std::vector<obs_scene_item *> &items)
 	}
 }
 
-void moveSceneItemsPos(std::vector<obs_scene_item *> &items, int pos)
+static void moveSceneItemsPos(std::vector<obs_scene_item *> &items, int pos)
 {
 	for (auto &i : items) {
 		obs_sceneitem_set_order_position(i, pos);
@@ -183,7 +184,7 @@ MacroActionSceneOrderEdit::MacroActionSceneOrderEdit(
 		{"{{actions}}", _actions},
 		{"{{position}}", _position},
 	};
-	placeWidgets(
+	PlaceWidgets(
 		obs_module_text("AdvSceneSwitcher.action.sceneOrder.entry"),
 		mainLayout, widgetPlaceholders);
 	setLayout(mainLayout);
@@ -213,7 +214,7 @@ void MacroActionSceneOrderEdit::SceneChanged(const SceneSelection &s)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_scene = s;
 }
 
@@ -223,7 +224,7 @@ void MacroActionSceneOrderEdit::SourceChanged(const SceneItemSelection &item)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_source = item;
 	emit HeaderInfoChanged(
 		QString::fromStdString(_entryData->GetShortDesc()));
@@ -235,7 +236,7 @@ void MacroActionSceneOrderEdit::ActionChanged(int value)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_action = static_cast<SceneOrderAction>(value);
 	_position->setVisible(_entryData->_action ==
 			      SceneOrderAction::POSITION);
@@ -247,6 +248,8 @@ void MacroActionSceneOrderEdit::PositionChanged(int value)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_position = value;
 }
+
+} // namespace advss

src/macro-core/macro-action-scene-order.hpp

@@ -5,6 +5,8 @@
 
 #include <QSpinBox>
 
+namespace advss {
+
 enum class SceneOrderAction {
 	MOVE_UP,
 	MOVE_DOWN,
@@ -73,3 +75,5 @@ private:
 	QHBoxLayout *_mainLayout;
 	bool _loading = true;
 };
+
+} // namespace advss

src/macro-core/macro-action-scene-switch.cpp

@@ -1,7 +1,10 @@
 #include "macro-action-scene-switch.hpp"
-#include "advanced-scene-switcher.hpp"
+#include "switcher-data.hpp"
+#include "scene-switch-helpers.hpp"
 #include "utility.hpp"
 
+namespace advss {
+
 using namespace std::chrono_literals;
 
 const std::string MacroActionSwitchScene::id = "scene_switch";
@@ -121,7 +124,7 @@ bool MacroActionSwitchScene::PerformAction()
 {
 	auto scene = _scene.GetScene();
 	auto transition = _transition.GetTransition();
-	switchScene({scene, transition, (int)(_duration.Milliseconds())},
+	SwitchScene({scene, transition, (int)(_duration.Milliseconds())},
 		    obs_frontend_preview_program_mode_active());
 	if (_blockUntilTransitionDone && scene) {
 		return WaitForTransition(scene, transition);
@@ -207,7 +210,7 @@ MacroActionSwitchSceneEdit::MacroActionSwitchSceneEdit(
 		{"{{duration}}", _duration},
 		{"{{blockUntilTransitionDone}}", _blockUntilTransitionDone},
 	};
-	placeWidgets(obs_module_text("AdvSceneSwitcher.action.scene.entry"),
+	PlaceWidgets(obs_module_text("AdvSceneSwitcher.action.scene.entry"),
 		     _entryLayout, widgetPlaceholders);
 
 	QVBoxLayout *mainLayout = new QVBoxLayout;
@@ -231,7 +234,7 @@ void MacroActionSwitchSceneEdit::DurationChanged(const Duration &dur)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_duration = dur;
 }
 
@@ -241,7 +244,7 @@ void MacroActionSwitchSceneEdit::BlockUntilTransitionDoneChanged(int state)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_blockUntilTransitionDone = state;
 }
 
@@ -258,19 +261,19 @@ void MacroActionSwitchSceneEdit::SetDurationVisibility()
 	_entryLayout->removeWidget(_scenes);
 	_entryLayout->removeWidget(_transitions);
 	_entryLayout->removeWidget(_duration);
-	clearLayout(_entryLayout);
+	ClearLayout(_entryLayout);
 	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
 		{"{{scenes}}", _scenes},
 		{"{{transitions}}", _transitions},
 		{"{{duration}}", _duration},
 	};
 	if (fixedDuration) {
-		placeWidgets(
+		PlaceWidgets(
 			obs_module_text(
 				"AdvSceneSwitcher.action.scene.entry.noDuration"),
 			_entryLayout, widgetPlaceholders);
 	} else {
-		placeWidgets(
+		PlaceWidgets(
 			obs_module_text("AdvSceneSwitcher.action.scene.entry"),
 			_entryLayout, widgetPlaceholders);
 	}
@@ -282,7 +285,7 @@ void MacroActionSwitchSceneEdit::SceneChanged(const SceneSelection &s)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_scene = s;
 	emit HeaderInfoChanged(
 		QString::fromStdString(_entryData->GetShortDesc()));
@@ -294,7 +297,9 @@ void MacroActionSwitchSceneEdit::TransitionChanged(const TransitionSelection &t)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_transition = t;
 	SetDurationVisibility();
 }
+
+} // namespace advss

src/macro-core/macro-action-scene-switch.hpp

@@ -6,6 +6,8 @@
 
 #include <QCheckBox>
 
+namespace advss {
+
 class MacroActionSwitchScene : public MacroAction {
 public:
 	MacroActionSwitchScene(Macro *m) : MacroAction(m) {}
@@ -69,3 +71,5 @@ private:
 	void SetDurationVisibility();
 	bool _loading = true;
 };
+
+} // namespace advss

src/macro-core/macro-action-scene-transform.cpp

@@ -1,7 +1,8 @@
 #include "macro-action-scene-transform.hpp"
-#include "advanced-scene-switcher.hpp"
 #include "utility.hpp"
 
+namespace advss {
+
 const std::string MacroActionSceneTransform::id = "scene_transform";
 
 bool MacroActionSceneTransform::_registered = MacroActionFactory::Register(
@@ -59,7 +60,7 @@ bool MacroActionSceneTransform::Load(obs_data_t *obj)
 	// Convert old data format
 	// TODO: Remove in future version
 	if (!obs_data_has_user_value(obj, "settings")) {
-		loadTransformState(obj, _info, _crop);
+		LoadTransformState(obj, _info, _crop);
 		_settings = ConvertSettings();
 	}
 	return true;
@@ -76,7 +77,7 @@ std::string MacroActionSceneTransform::GetShortDesc() const
 std::string MacroActionSceneTransform::ConvertSettings()
 {
 	auto data = obs_data_create();
-	saveTransformState(data, _info, _crop);
+	SaveTransformState(data, _info, _crop);
 	std::string json = obs_data_get_json(data);
 	obs_data_release(data);
 	return json;
@@ -88,7 +89,7 @@ void MacroActionSceneTransform::ApplySettings(const std::string &settings)
 	if (!data) {
 		return;
 	}
-	loadTransformState(data, _info, _crop);
+	LoadTransformState(data, _info, _crop);
 	auto items = _source.GetSceneItems(_scene);
 	if (items.empty()) {
 		return;
@@ -142,7 +143,7 @@ MacroActionSceneTransformEdit::MacroActionSceneTransformEdit(
 		{"{{settings}}", _settings},
 		{"{{getSettings}}", _getSettings},
 	};
-	placeWidgets(
+	PlaceWidgets(
 		obs_module_text("AdvSceneSwitcher.action.sceneTransform.entry"),
 		entryLayout, widgetPlaceholders);
 
@@ -181,7 +182,7 @@ void MacroActionSceneTransformEdit::SceneChanged(const SceneSelection &s)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_scene = s;
 }
 
@@ -191,7 +192,7 @@ void MacroActionSceneTransformEdit::SourceChanged(const SceneItemSelection &item
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_source = item;
 	emit HeaderInfoChanged(
 		QString::fromStdString(_entryData->GetShortDesc()));
@@ -208,8 +209,8 @@ void MacroActionSceneTransformEdit::GetSettingsClicked()
 		return;
 	}
 
-	auto settings = getSceneItemTransform(items[0]);
-	_settings->setPlainText(formatJsonString(settings));
+	auto settings = GetSceneItemTransform(items[0]);
+	_settings->setPlainText(FormatJsonString(settings));
 	for (auto item : items) {
 		obs_sceneitem_release(item);
 	}
@@ -221,9 +222,11 @@ void MacroActionSceneTransformEdit::SettingsChanged()
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_settings = _settings->toPlainText().toStdString();
 
 	adjustSize();
 	updateGeometry();
 }
+
+} // namespace advss

src/macro-core/macro-action-scene-transform.hpp

@@ -6,6 +6,8 @@
 
 #include <QSpinBox>
 
+namespace advss {
+
 class MacroActionSceneTransform : public MacroAction {
 public:
 	MacroActionSceneTransform(Macro *m) : MacroAction(m) {}
@@ -70,3 +72,5 @@ protected:
 private:
 	bool _loading = true;
 };
+
+} // namespace advss

src/macro-core/macro-action-scene-visibility.cpp

@@ -1,7 +1,8 @@
 #include "macro-action-scene-visibility.hpp"
-#include "advanced-scene-switcher.hpp"
 #include "utility.hpp"
 
+namespace advss {
+
 const std::string MacroActionSceneVisibility::id = "scene_visibility";
 
 bool MacroActionSceneVisibility::_registered = MacroActionFactory::Register(
@@ -190,7 +191,7 @@ MacroActionSceneVisibilityEdit::MacroActionSceneVisibilityEdit(
 	_actions = new QComboBox();
 
 	populateSourceItemTypeSelection(_sourceTypes);
-	populateSourceGroupSelection(_sourceGroups);
+	PopulateSourceGroupSelection(_sourceGroups);
 	populateActionSelection(_actions);
 
 	QWidget::connect(_actions, SIGNAL(currentIndexChanged(int)), this,
@@ -214,7 +215,7 @@ MacroActionSceneVisibilityEdit::MacroActionSceneVisibilityEdit(
 		{"{{sources}}", _sources}, {"{{sourceGroups}}", _sourceGroups},
 		{"{{actions}}", _actions},
 	};
-	placeWidgets(obs_module_text(
+	PlaceWidgets(obs_module_text(
 			     "AdvSceneSwitcher.action.sceneVisibility.entry"),
 		     mainLayout, widgetPlaceholders);
 	setLayout(mainLayout);
@@ -246,7 +247,7 @@ void MacroActionSceneVisibilityEdit::SceneChanged(const SceneSelection &s)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_scene = s;
 }
 
@@ -256,7 +257,7 @@ void MacroActionSceneVisibilityEdit::SourceTypeChanged(int value)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_sourceType = static_cast<SceneItemSourceType>(value);
 	SetWidgetVisibility();
 }
@@ -268,7 +269,7 @@ void MacroActionSceneVisibilityEdit::SourceChanged(
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_source = item;
 	emit HeaderInfoChanged(
 		QString::fromStdString(_entryData->GetShortDesc()));
@@ -280,7 +281,7 @@ void MacroActionSceneVisibilityEdit::SourceGroupChanged(const QString &text)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	if (text == obs_module_text("AdvSceneSwitcher.selectItem")) {
 		_entryData->_sourceGroup = "";
 	} else {
@@ -296,7 +297,7 @@ void MacroActionSceneVisibilityEdit::ActionChanged(int value)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_action = static_cast<SceneVisibilityAction>(value);
 }
 
@@ -311,3 +312,5 @@ void MacroActionSceneVisibilityEdit::SetWidgetVisibility()
 				  SceneItemSourceType::SOURCE_GROUP);
 	adjustSize();
 }
+
+} // namespace advss

src/macro-core/macro-action-scene-visibility.hpp

@@ -5,6 +5,8 @@
 
 #include <QSpinBox>
 
+namespace advss {
+
 enum class SceneVisibilityAction {
 	SHOW,
 	HIDE,
@@ -81,3 +83,5 @@ private:
 	QHBoxLayout *_mainLayout;
 	bool _loading = true;
 };
+
+} // namespace advss

src/macro-core/macro-action-screenshot.cpp

@@ -1,7 +1,8 @@
 #include "macro-action-screenshot.hpp"
-#include "advanced-scene-switcher.hpp"
 #include "utility.hpp"
 
+namespace advss {
+
 const uint32_t MacroActionScreenshot::_version = 1;
 
 const std::string MacroActionScreenshot::id = "screenshot";
@@ -176,7 +177,7 @@ MacroActionScreenshotEdit::MacroActionScreenshotEdit(
 		{"{{saveType}}", _saveType},
 		{"{{targetType}}", _targetType},
 	};
-	placeWidgets(
+	PlaceWidgets(
 		obs_module_text("AdvSceneSwitcher.action.screenshot.entry"),
 		layout, widgetPlaceholders);
 
@@ -210,7 +211,7 @@ void MacroActionScreenshotEdit::SceneChanged(const SceneSelection &s)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_scene = s;
 	emit HeaderInfoChanged(
 		QString::fromStdString(_entryData->GetShortDesc()));
@@ -242,7 +243,7 @@ void MacroActionScreenshotEdit::PathChanged(const QString &text)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_path = text.toStdString();
 }
 
@@ -252,7 +253,7 @@ void MacroActionScreenshotEdit::SourceChanged(const SourceSelection &source)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_source = source;
 	emit HeaderInfoChanged(
 		QString::fromStdString(_entryData->GetShortDesc()));
@@ -272,3 +273,5 @@ void MacroActionScreenshotEdit::SetWidgetVisibility()
 
 	adjustSize();
 }
+
+} // namespace advss

src/macro-core/macro-action-screenshot.hpp

@@ -7,6 +7,8 @@
 
 #include <QComboBox>
 
+namespace advss {
+
 class MacroActionScreenshot : public MacroAction {
 public:
 	MacroActionScreenshot(Macro *m) : MacroAction(m) {}
@@ -84,3 +86,5 @@ private:
 
 	bool _loading = true;
 };
+
+} // namespace advss

src/macro-core/macro-action-sequence.cpp

@@ -1,7 +1,9 @@
 #include "macro-action-sequence.hpp"
-#include "advanced-scene-switcher.hpp"
+#include "macro.hpp"
 #include "utility.hpp"
 
+namespace advss {
+
 const std::string MacroActionSequence::id = "sequence";
 
 bool MacroActionSequence::_registered = MacroActionFactory::Register(
@@ -9,7 +11,7 @@ bool MacroActionSequence::_registered = MacroActionFactory::Register(
 	{MacroActionSequence::Create, MacroActionSequenceEdit::Create,
 	 "AdvSceneSwitcher.action.sequence"});
 
-int getNextUnpausedMacroIdx(std::vector<MacroRef> &macros, int startIdx)
+static int getNextUnpausedMacroIdx(std::vector<MacroRef> &macros, int startIdx)
 {
 	for (; (int)macros.size() > startIdx; ++startIdx) {
 		auto macro = macros[startIdx].GetMacro();
@@ -120,7 +122,7 @@ MacroActionSequenceEdit::MacroActionSequenceEdit(
 
 	auto *entryLayout = new QHBoxLayout;
 	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {};
-	placeWidgets(obs_module_text("AdvSceneSwitcher.action.sequence.entry"),
+	PlaceWidgets(obs_module_text("AdvSceneSwitcher.action.sequence.entry"),
 		     entryLayout, widgetPlaceholders);
 
 	auto *mainLayout = new QVBoxLayout;
@@ -175,7 +177,7 @@ void MacroActionSequenceEdit::Add(const std::string &name)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	MacroRef macro(name);
 	_entryData->_macros.push_back(macro);
 	adjustSize();
@@ -187,7 +189,7 @@ void MacroActionSequenceEdit::Remove(int idx)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_macros.erase(std::next(_entryData->_macros.begin(), idx));
 	adjustSize();
 }
@@ -198,13 +200,13 @@ void MacroActionSequenceEdit::Up(int idx)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	std::swap(_entryData->_macros[idx], _entryData->_macros[idx - 1]);
 }
 
 void MacroActionSequenceEdit::Down(int idx)
 {
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	std::swap(_entryData->_macros[idx], _entryData->_macros[idx + 1]);
 }
 
@@ -215,7 +217,7 @@ void MacroActionSequenceEdit::Replace(int idx, const std::string &name)
 	}
 
 	MacroRef macro(name);
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_macros[idx] = macro;
 	adjustSize();
 }
@@ -230,7 +232,7 @@ void MacroActionSequenceEdit::ContinueFromClicked()
 	if (idx == -1) {
 		return;
 	}
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_lastIdx = idx - 1;
 }
 
@@ -240,7 +242,7 @@ void MacroActionSequenceEdit::RestartChanged(int state)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_entryData->_restart = state;
 }
 
@@ -264,3 +266,5 @@ void MacroActionSequenceEdit::UpdateStatusLine()
 		obs_module_text("AdvSceneSwitcher.action.sequence.status")};
 	_statusLine->setText(format.arg(lastMacroName, nextMacroName));
 }
+
+} // namespace advss