Fix regex matching for window tab (#113)

Regex matches could never match if full-screen or maximized was selected due to only checking for direct matches during these checks.

.github/workflows/build.yml

@@ -15,16 +15,16 @@ jobs:
     name: "macOS 64-bit"
     runs-on: [macos-latest]
     env:
-      QT_VERSION: 5.14.1
-      MACOS_DEPS_VERSION: '2020-08-30'
+      QT_VERSION: '5.15.2'
+      MACOS_DEPS_VERSION: '2020-12-11'
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v2.3.4
         with:
           repository: obsproject/obs-studio
           submodules: 'recursive'
       - name: "Checkout plugin"
-        uses: actions/checkout@v2
+        uses: actions/checkout@v2.3.4
         with:
           path: UI/frontend-plugins/${{ env.PLUGIN_NAME }}
       - name: Fetch Git Tags
@@ -34,12 +34,15 @@ jobs:
       - name: 'Install prerequisites (Homebrew)'
         shell: bash
         run: |
-          cd UI/frontend-plugins/${{ env.PLUGIN_NAME }}/CI/macos
-          brew untap local/openssl
-          brew untap local/python2
-          brew update
-          brew bundle
-          cd -
+          if [ -d /usr/local/opt/openssl@1.0.2t ]; then
+              brew uninstall openssl@1.0.2t
+              brew untap local/openssl
+          fi
+          if [ -d /usr/local/opt/python@2.7.17 ]; then
+              brew uninstall python@2.7.17
+              brew untap local/python2
+          fi
+          brew bundle --file ./CI/scripts/macos/Brewfile
       - name: 'Install prerequisite: Pre-built dependencies'
         if: steps.deps-cache.outputs.cache-hit != 'true'
         shell: bash
@@ -59,7 +62,7 @@ jobs:
           echo "add_subdirectory(${{ env.PLUGIN_NAME }})" >> UI/frontend-plugins/CMakeLists.txt
           mkdir ./build
           cd ./build
-          cmake -DCMAKE_OSX_DEPLOYMENT_TARGET=10.11 -DDISABLE_PYTHON=ON -DDepsPath="/tmp/obsdeps" -DQTDIR="/tmp/obsdeps" ..
+          cmake -DCMAKE_OSX_DEPLOYMENT_TARGET=10.13 -DDISABLE_PYTHON=ON -DDepsPath="/tmp/obsdeps" -DQTDIR="/tmp/obsdeps" ..
           cd -
       - name: Build
         shell: bash
@@ -86,14 +89,14 @@ jobs:
           install_name_tool -change /tmp/obsdeps/lib/QtCore.framework/Versions/5/QtCore @executable_path/../Frameworks/QtCore.framework/Versions/5/QtCore ../../../build/UI/frontend-plugins/SceneSwitcher/advanced-scene-switcher.so
           FILE_DATE=$(date +%Y-%m-%d)
           FILE_NAME=${{ env.PLUGIN_NAME }}-$FILE_DATE-${{ github.sha }}-macos.pkg
-          echo "::set-env name=FILE_NAME::${FILE_NAME}"
+          echo "FILE_NAME=${FILE_NAME}" >> $GITHUB_ENV
           packagesbuild ./CI/macos/${{ env.PLUGIN_NAME }}.pkgproj
           cd -
           mkdir ./nightly
           mv UI/frontend-plugins/${{ env.PLUGIN_NAME }}/${{ env.PLUGIN_NAME }}.pkg ./nightly/${FILE_NAME}
       - name: Publish
         if: success()
-        uses: actions/upload-artifact@v2-preview
+        uses: actions/upload-artifact@v2.2.1
         with:
           name: '${{ env.FILE_NAME }}'
           path: ./nightly/*.pkg
@@ -102,12 +105,12 @@ jobs:
     runs-on: [ubuntu-latest]
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v2.3.4
         with:
           repository: obsproject/obs-studio
           submodules: 'recursive'
       - name: "Checkout plugin"
-        uses: actions/checkout@v2
+        uses: actions/checkout@v2.3.4
         with:
           path: UI/frontend-plugins/${{ env.PLUGIN_NAME }}
       - name: Add plugin to obs cmake
@@ -166,7 +169,7 @@ jobs:
         run: |
           mkdir ./build
           cd ./build
-          cmake -DUNIX_STRUCTURE=0 -DCMAKE_INSTALL_PREFIX="${{ github.workspace }}/obs-studio-portable" -DBUILD_CAPTIONS=OFF -DWITH_RTMPS=OFF -DBUILD_BROWSER=OFF ..
+          cmake -DUNIX_STRUCTURE=0 -DCMAKE_INSTALL_PREFIX="${{ github.workspace }}/obs-studio-portable" -DWITH_RTMPS=OFF -DBUILD_BROWSER=OFF ..
       - name: 'Build'
         shell: bash
         working-directory: ${{ github.workspace }}/build
@@ -176,32 +179,34 @@ jobs:
         run: |
           FILE_DATE=$(date +%Y-%m-%d)
           FILE_NAME=${{ env.PLUGIN_NAME }}-$FILE_DATE-${{ github.sha }}-linux64.tar.gz
-          echo "::set-env name=FILE_NAME::${FILE_NAME}"
-          mkdir -p ./${{ env.PLUGIN_NAME }}/bin/64bit/
-          mv ./build/UI/frontend-plugins/${{ env.PLUGIN_NAME }}/${{ env.LIB_NAME }}.so ./${{ env.PLUGIN_NAME }}/bin/64bit/${{ env.LIB_NAME }}.so
-          tar -cvzf "${FILE_NAME}" ${{ env.PLUGIN_NAME }}
+          echo "FILE_NAME=${FILE_NAME}" >> $GITHUB_ENV
+          mkdir -p ./${{ env.LIB_NAME }}/bin/64bit/
+          mv ./build/UI/frontend-plugins/${{ env.PLUGIN_NAME }}/${{ env.LIB_NAME }}.so ./${{ env.LIB_NAME }}/bin/64bit/${{ env.LIB_NAME }}.so
+          mv ./UI/frontend-plugins/${{ env.PLUGIN_NAME }}/data ./${{ env.LIB_NAME }}/data
+          tar -cvzf "${FILE_NAME}" ${{ env.LIB_NAME }}
       - name: 'Publish'
-        uses: actions/upload-artifact@v2-preview
+        uses: actions/upload-artifact@v2.2.1
         with:
           name: '${{ env.FILE_NAME }}'
           path: '*.tar.gz'
-  win64:
-    name: Windows 64-bit
+  windows:
+    name: Windows
     runs-on: [windows-latest]
     env:
       QT_VERSION: 5.10.1
       CMAKE_GENERATOR: "Visual Studio 16 2019"
       CMAKE_SYSTEM_VERSION: "10.0.18363.657"
+      WINDOWS_DEPS_VERSION: '2017'
     steps:
       - name: Add msbuild to PATH
-        uses: microsoft/setup-msbuild@v1.0.0
+        uses: microsoft/setup-msbuild@v1.0.2
       - name: Checkout obs
-        uses: actions/checkout@v2
+        uses: actions/checkout@v2.3.4
         with:
           repository: obsproject/obs-studio
           submodules: 'recursive'
       - name: Checkout plugin
-        uses: actions/checkout@v2
+        uses: actions/checkout@v2.3.4
         with:
           path: UI/frontend-plugins/${{ env.PLUGIN_NAME}}
       - name: Add plugin to obs cmake
@@ -215,81 +220,82 @@ jobs:
           7z x Qt_${{ env.QT_VERSION }}.7z -o"${{ github.workspace }}/cmbuild/QT"
       - name: 'Install prerequisite: Pre-built dependencies'
         run: |
-          curl -kLO https://cdn-fastly.obsproject.com/downloads/dependencies2017.zip -f --retry 5 -C -
-          7z x dependencies2017.zip -o"${{ github.workspace }}/cmbuild/deps"
+          curl -kLO https://cdn-fastly.obsproject.com/downloads/dependencies${{ env.WINDOWS_DEPS_VERSION }}.zip -f --retry 5 -C -
+          7z x dependencies${{ env.WINDOWS_DEPS_VERSION }}.zip -o"${{ github.workspace }}/cmbuild/deps"
       - name: Configure
         run: |
-          mkdir ./build
+          mkdir ./package
+          mkdir ./build32
+          cd ./build32
+          cmake -G"${{ env.CMAKE_GENERATOR }}" -A"Win32" -DCMAKE_SYSTEM_VERSION="${{ env.CMAKE_SYSTEM_VERSION }}" -DBUILD_BROWSER=false -DBUILD_CAPTIONS=false -DCOMPILE_D3D12_HOOK=false -DDepsPath="${{ github.workspace }}/cmbuild/deps/win32" -DQTDIR="${{ github.workspace }}/cmbuild/QT/${{ env.QT_VERSION }}/msvc2017" -DCOPIED_DEPENDENCIES=FALSE -DCOPY_DEPENDENCIES=TRUE ..
+          cd ..
           mkdir ./build64
           cd ./build64
           cmake -G"${{ env.CMAKE_GENERATOR }}" -A"x64" -DCMAKE_SYSTEM_VERSION="${{ env.CMAKE_SYSTEM_VERSION }}" -DBUILD_BROWSER=false -DBUILD_CAPTIONS=false -DCOMPILE_D3D12_HOOK=false -DDepsPath="${{ github.workspace }}/cmbuild/deps/win64" -DQTDIR="${{ github.workspace }}/cmbuild/QT/${{ env.QT_VERSION }}/msvc2017_64" -DCOPIED_DEPENDENCIES=FALSE -DCOPY_DEPENDENCIES=TRUE ..
       - name: Build
-        run: msbuild /m /p:Configuration=RelWithDebInfo .\build64\obs-studio.sln
+        run: |
+          msbuild /m /p:Configuration=RelWithDebInfo .\build32\obs-studio.sln
+          msbuild /m /p:Configuration=RelWithDebInfo .\build64\obs-studio.sln
       - name: Package
         if: success()
         run: |
           $env:FILE_DATE=(Get-Date -UFormat "%F")
-          $env:FILE_NAME="${{ env.PLUGIN_NAME }}-${env:FILE_DATE}-${{ github.sha }}-win64.zip"
-          echo "::set-env name=FILE_NAME::${env:FILE_NAME}"
-          robocopy .\build64\rundir\RelWithDebInfo\obs-plugins\64bit\ .\build\obs-plugins\64bit ${{ env.LIB_NAME }}.* /E /XF .gitignore
-          7z a ${env:FILE_NAME} .\build\*
-      - name: Publish
+          $env:FILE_NAME="${{ env.PLUGIN_NAME }}-${env:FILE_DATE}-${{ github.sha }}-windows"
+          echo "FILE_NAME=${env:FILE_NAME}" >> ${env:GITHUB_ENV}
+          robocopy .\build32\rundir\RelWithDebInfo\obs-plugins\32bit\ .\package\obs-plugins\32bit ${{ env.LIB_NAME }}.* /E /XF .gitignore
+          robocopy .\build64\rundir\RelWithDebInfo\obs-plugins\64bit\ .\package\obs-plugins\64bit ${{ env.LIB_NAME }}.* /E /XF .gitignore
+          robocopy .\build64\rundir\RelWithDebInfo\data\obs-plugins\${{ env.LIB_NAME }}\ .\package\data\obs-plugins\${{ env.LIB_NAME }}\ /E /XF .gitignore
+          exit 0
+      - name: Publish zip
         if: success()
-        uses: actions/upload-artifact@v2-preview
+        uses: actions/upload-artifact@v2.2.1
         with:
           name: '${{ env.FILE_NAME }}'
-          path: '*-win64.zip'
-  win32:
-    name: Windows 32-bit
-    runs-on: [windows-latest]
-    env:
-      QT_VERSION: 5.10.1
-      CMAKE_GENERATOR: "Visual Studio 16 2019"
-      CMAKE_SYSTEM_VERSION: "10.0.18363.657"
+          path: package/*
+      - name: "Package Installer (Prereqs)"
+        run: |
+          curl "-kL" "https://github.com/Xaymar/msvc-redist-helper/releases/download/0.1/msvc-redist-helper-64.exe" "-f" "--retry" "5" "-o" "msvc-redist-helper-64.exe"
+          curl "-kL" "https://github.com/Xaymar/msvc-redist-helper/releases/download/0.1/msvc-redist-helper-32.exe" "-f" "--retry" "5" "-o" "msvc-redist-helper-32.exe"
+          curl "-kL" "https://files.jrsoftware.org/is/6/innosetup-6.0.3.exe" "-f" "--retry" "5" "-o" "inno.exe"
+          .\inno.exe /VERYSILENT /SP- /SUPPRESSMSGBOXES /NORESTART
+      - name: "Package Installer (Compile)"
+        run: |
+          & 'C:\Program Files (x86)\Inno Setup 6\ISCC.exe' /Qp ".\build64\UI\frontend-plugins\${{ env.PLUGIN_NAME }}\CI\windows\setup.iss"
+      - name: Publish installer
+        if: success()
+        uses: actions/upload-artifact@v2.2.0
+        with:
+          name: '${{ env.FILE_NAME }}-installer'
+          path: build64/UI/frontend-plugins/SceneSwitcher/CI/windows/Output/*.exe
+  release:
+    needs: [macos64, ubuntu64, windows]
+    name: 'Create Release'
+    runs-on: [ubuntu-latest]
     steps:
-      - name: Add msbuild to PATH
-        uses: microsoft/setup-msbuild@v1.0.0
-      - name: Checkout obs
-        uses: actions/checkout@v2
+      - name: "Checkout plugin"
+        uses: actions/checkout@v2.3.4
         with:
-          repository: obsproject/obs-studio
-          submodules: 'recursive'
-      - name: Checkout plugin
-        uses: actions/checkout@v2
+          path: plugin/${{ env.PLUGIN_NAME }}
+      - name: Download artifacts
+        uses: actions/download-artifact@v2
         with:
-          path: UI/frontend-plugins/${{ env.PLUGIN_NAME }}
-      - name: Add plugin to obs cmake
-        shell: cmd
-        run: echo add_subdirectory(${{ env.PLUGIN_NAME }}) >> UI/frontend-plugins/CMakeLists.txt
-      - name: Fetch Git Tags
-        run: git fetch --prune --tags --unshallow
-      - name: 'Install prerequisite: QT'
+          path: artifacts
+      - name: 'Package'
+        shell: bash
         run: |
-          curl -kLO https://cdn-fastly.obsproject.com/downloads/Qt_${{ env.QT_VERSION }}.7z -f --retry 5 -C -
-          7z x Qt_${{ env.QT_VERSION }}.7z -o"${{ github.workspace }}/cmbuild/QT"
-      - name: 'Install prerequisite: Pre-built dependencies'
-        run: |
-          curl -kLO https://cdn-fastly.obsproject.com/downloads/dependencies2017.zip -f --retry 5 -C -
-          7z x dependencies2017.zip -o"${{ github.workspace }}/cmbuild/deps"
-      - name: Configure
-        run: |
-          mkdir ./build
-          mkdir ./build32
-          cd ./build32
-          cmake -G"${{ env.CMAKE_GENERATOR }}" -A"Win32" -DCMAKE_SYSTEM_VERSION="${{ env.CMAKE_SYSTEM_VERSION }}" -DBUILD_BROWSER=false -DBUILD_CAPTIONS=false -DCOMPILE_D3D12_HOOK=false -DDepsPath="${{ github.workspace }}/cmbuild/deps/win32" -DQTDIR="${{ github.workspace }}/cmbuild/QT/${{ env.QT_VERSION }}/msvc2017" -DCOPIED_DEPENDENCIES=FALSE -DCOPY_DEPENDENCIES=TRUE ..
-      - name: Build
-        run: msbuild /m /p:Configuration=RelWithDebInfo .\build32\obs-studio.sln
-      - name: Package
-        if: success()
-        run: |
-          $env:FILE_DATE=(Get-Date -UFormat "%F")
-          $env:FILE_NAME="${{ env.PLUGIN_NAME }}-${env:FILE_DATE}-${{ github.sha }}-win32.zip"
-          echo "::set-env name=FILE_NAME::${env:FILE_NAME}"
-          robocopy .\build32\rundir\RelWithDebInfo\obs-plugins\32bit\ .\build\obs-plugins\32bit ${{ env.LIB_NAME }}.* /E /XF .gitignore
-          7z a ${env:FILE_NAME} .\build\*
+          mkdir -p ${{ env.PLUGIN_NAME }}/Linux ${{ env.PLUGIN_NAME }}/MacOs ${{ env.PLUGIN_NAME }}/Windows
+          tar xf artifacts/${{ env.PLUGIN_NAME }}*-linux64.tar.gz/${{ env.PLUGIN_NAME }}*-linux64.tar.gz -C ${{ env.PLUGIN_NAME }}/Linux/
+          mv artifacts/${{ env.PLUGIN_NAME }}*-macos.pkg/${{ env.PLUGIN_NAME }}*-macos.pkg ${{ env.PLUGIN_NAME }}/MacOs/${{ env.PLUGIN_NAME }}.pkg
+          mv ./artifacts/${{ env.PLUGIN_NAME }}*-windows/* ${{ env.PLUGIN_NAME }}/Windows/
+          mv ./artifacts/${{ env.PLUGIN_NAME }}*-windows-installer/*.exe ${{ env.PLUGIN_NAME }}/Windows/
+          rm ${{ env.PLUGIN_NAME }}/Windows/obs-plugins/32bit/advanced-scene-switcher.pdb
+          rm ${{ env.PLUGIN_NAME }}/Windows/obs-plugins/64bit/advanced-scene-switcher.pdb
+          cp plugin/${{ env.PLUGIN_NAME }}/CI/release/README.txt ${{ env.PLUGIN_NAME }}/
+          FILE_NAME=${{ env.PLUGIN_NAME }}.zip
+          zip -r ${FILE_NAME} ${{ env.PLUGIN_NAME }}/
       - name: Publish
         if: success()
-        uses: actions/upload-artifact@v2-preview
+        uses: actions/upload-artifact@v2.2.1
         with:
-          name: '${{ env.FILE_NAME }}'
-          path: '*-win32.zip'
+          name: "Release"
+          path: '*.zip'

.github/workflows/clang-format.yml

@@ -0,0 +1,32 @@
+name: Clang Format Check
+
+on: [push, pull_request]
+
+jobs:
+  ubuntu64:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+        with:
+          submodules: 'recursive'
+
+      - name: Install clang format
+        run: |
+          # gets us newer clang
+          sudo bash -c "cat >> /etc/apt/sources.list" << LLVMAPT
+          # 3.8
+          deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-8 main
+          deb-src http://apt.llvm.org/xenial/ llvm-toolchain-xenial-8 main
+          LLVMAPT
+
+          wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key|sudo apt-key add -
+
+          sudo apt-get -qq update
+
+          sudo apt-get install -y clang-format-8
+
+      - name: Check the Formatting
+        run: |
+          ./CI/formatcode.sh
+          ./CI/check-format.sh

CI/check-format.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+dirty=$(git ls-files --modified)
+
+set +x
+if [[ $dirty ]]; then
+	echo "================================="
+    echo "Files were not formatted properly"
+    echo "$dirty"
+    echo "================================="
+    exit 1
+fi

CI/formatcode.sh

@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+# Original source https://github.com/Project-OSRM/osrm-backend/blob/master/scripts/format.sh
+
+set +x
+set -o errexit
+set -o pipefail
+set -o nounset
+
+# Runs the Clang Formatter in parallel on the code base.
+# Return codes:
+#  - 1 there are files to be formatted
+#  - 0 everything looks fine
+
+# Get CPU count
+OS=$(uname)
+NPROC=1
+if [[ $OS = "Linux" || $OS = "Darwin" ]] ; then
+    NPROC=$(getconf _NPROCESSORS_ONLN)
+fi
+
+# Discover clang-format
+if type clang-format-8 2> /dev/null ; then
+    CLANG_FORMAT=clang-format-8
+else
+    CLANG_FORMAT=clang-format
+fi
+
+find .. -type d \( -path ./deps \
+-o -path ./cmake \
+-o -path ./build \) -prune -type f -o -name '*.h' -or -name '*.hpp' -or -name '*.m' -or -name '*.mm' -or -name '*.c' -or -name '*.cpp' \
+| xargs -L100 -P${NPROC} ${CLANG_FORMAT} -i -style=file  -fallback-style=none

CI/macos/SceneSwitcher.pkgproj

@@ -60,6 +60,22 @@
 																<key>UID</key>
 																<integer>0</integer>
 															</dict>
+															<dict>
+																<key>CHILDREN</key>
+																<array/>
+																<key>GID</key>
+																<integer>80</integer>
+																<key>PATH</key>
+																<string>../../data</string>
+																<key>PATH_TYPE</key>
+																<integer>1</integer>
+																<key>PERMISSIONS</key>
+																<integer>493</integer>
+																<key>TYPE</key>
+																<integer>3</integer>
+																<key>UID</key>
+																<integer>0</integer>
+															</dict>
 														</array>
 														<key>GID</key>
 														<integer>80</integer>

CI/release/README.txt

@@ -0,0 +1,38 @@
+Note that you will have to use OBS version 26.1 or newer!
+
+--- Windows ---
+Recommended: Run the provided installer. (You might have to click 'More info' and select 'Run anyway' if it is blocked by Windows)
+
+Alternatively manually copy the 'obs-plugins' and 'data' folders in the respective OBS Studio installation directory.
+It is usually located at 'C:\Program Files (x86)\obs-studio\'.
+Remember to install the Visual C++ Redistributable for Visual Studio 2019, if you have not done so already. (See plugin overview page)
+
+--- macOS ---
+Recommended: Run the provided installer. (You might have to right-click or control-click and select 'open' if it is blocked)
+
+Alternatively extract the *so file and data folder and either ...
+
+... right-click the OBS app inside your Applications folder and choose 'Show Package Contents'.
+Copy the advanced-scene-switcher.so file to 'Contents/Plugins' and the 'data' folder to 'Contents/Resources'.
+
+... or copy the advanced-scene-switcher.so file to Library/Application Support/obs-studio/plugins/advanced-scene-switcher/bin/ .
+And the 'data' folder to 'Library/Application Support/obs-studio/plugins/advanced-scene-switcher/'.
+
+--- Linux ---
+Copy the advanced-scene-switcher.so file and into the OBS Studio plugin folder.
+The location of this folder can vary, so you might have to look around a bit.
+
+Examples are ...
+/usr/lib/obs-plugins/
+/usr/lib/x86_64-linux-gnu/obs-plugins/
+/usr/share/obs/obs-plugins/
+~/.config/obs-studio/plugins/advanced-scene-switcher/bin/64bit/
+
+Unfortunately the expected location of the locale, which can be found in the data folder, can vary also.
+The data folder usually should be copied to:
+~/.config/obs-studio/plugins/advanced-scene-switcher/
+
+If this does not work you can try to copy the "locale" folder found inside the data folder to:
+/usr/share/obs/obs-plugins/advanced-scene-switcher/locale
+
+In doubt please check where other "en-US.ini" files are located on your system.

CI/windows/setup.iss.in

@@ -0,0 +1,64 @@
+; Script generated by the Inno Setup Script Wizard.
+; SEE THE DOCUMENTATION FOR DETAILS ON CREATING INNO SETUP SCRIPT FILES!
+
+#define MyAppName "Advanced Scene Switcher"
+#define MyAppVersion "@GIT_SHA1@"
+#define MyAppURL "https://github.com/WarmUpTill/SceneSwitcher"
+
+[Setup]
+; NOTE: The value of AppId uniquely identifies this application. Do not use the same AppId value in installers for other applications.
+; (To generate a new GUID, click Tools | Generate GUID inside the IDE.)
+AppId={{A4ADDF26-4426-4D2E-B26A-C7C878DA8FC9}
+AppName={#MyAppName}
+AppVersion={#MyAppVersion}
+AppPublisherURL={#MyAppURL}
+AppSupportURL={#MyAppURL}
+AppUpdatesURL={#MyAppURL}
+DefaultDirName={code:GetDirName}
+DefaultGroupName={#MyAppName}
+AllowNoIcons=yes
+; Uncomment the following line to run in non administrative install mode (install for current user only.)
+;PrivilegesRequired=lowest
+OutputBaseFilename=AdvancedSceneSwitcherSetup
+Compression=lzma
+SolidCompression=yes
+WizardStyle=modern
+ArchitecturesInstallIn64BitMode=x64
+
+[Languages]
+Name: "english"; MessagesFile: "compiler:Default.isl"
+
+[Files]
+Source: "@ISS_MSVC_REDIST_HELPER_DIR@\msvc-redist-helper-64.exe"; DestDir: "{app}"; DestName: "msvc-redist-helper.exe"; Flags: ignoreversion dontcopy; Check: Is64BitInstallMode
+Source: "@ISS_MSVC_REDIST_HELPER_DIR@\msvc-redist-helper-32.exe"; DestDir: "{app}"; DestName: "msvc-redist-helper.exe"; Flags: ignoreversion dontcopy; Check: not Is64BitInstallMode
+Source: "@ISS_PLUGIN_FILES_DIR@\*"; DestDir: "{app}"; Flags: ignoreversion recursesubdirs createallsubdirs
+; NOTE: Don't use "Flags: ignoreversion" on any shared system files
+
+[Icons]
+Name: "{group}\{cm:UninstallProgram,{#MyAppName}}"; Filename: "{uninstallexe}"
+
+[Code]
+// credit where it's due:
+// following function comes from https://github.com/Xaymar/obs-studio_amf-encoder-plugin/blob/master/%23Resources/Installer.in.iss#L45
+function GetDirName(Value: string): string;
+var
+  InstallPath: string;
+begin
+  // initialize default path, which will be returned when the following registry
+  // key queries fail due to missing keys or for some different reason
+  Result := ExpandConstant('{pf}\obs-studio');
+  // query the first registry value; if this succeeds, return the obtained value
+  if RegQueryStringValue(HKLM32, 'SOFTWARE\OBS Studio', '', InstallPath) then
+    Result := InstallPath
+end;
+
+procedure CurStepChanged(CurStep: TSetupStep);
+var
+  ResultCode: Integer;
+begin
+  if (CurStep=ssPostInstall) then
+  begin
+    ExtractTemporaryFile('msvc-redist-helper.exe');
+    Exec(ExpandConstant('{tmp}\msvc-redist-helper.exe'), '2019', '', SW_HIDE, ewWaitUntilTerminated, ResultCode);
+  end;
+end;

CMakeLists.txt

@@ -2,9 +2,21 @@ cmake_minimum_required(VERSION 3.5)
 
 project(advanced-scene-switcher)
 
+# generate version info
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/")
+include(GetGitRevisionDescription)
+get_git_head_revision(GIT_REFSPEC GIT_SHA1)
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/cmake/version.cpp.in" "${CMAKE_CURRENT_BINARY_DIR}/src/version.cpp" @ONLY)
+
+if(WIN32)
+	get_filename_component(ISS_PLUGIN_FILES_DIR "${CMAKE_BINARY_DIR}\\..\\package" ABSOLUTE)
+	file(TO_NATIVE_PATH "${ISS_PLUGIN_FILES_DIR}" ISS_PLUGIN_FILES_DIR)
+	get_filename_component(ISS_MSVC_REDIST_HELPER_DIR "${CMAKE_PACKAGE_PREFIX}\\.." ABSOLUTE)
+	file(TO_NATIVE_PATH "${ISS_MSVC_REDIST_HELPER_DIR}" ISS_MSVC_REDIST_HELPER_DIR)
+	configure_file("${CMAKE_CURRENT_SOURCE_DIR}/CI/windows/setup.iss.in" "${CMAKE_CURRENT_BINARY_DIR}/CI/windows/setup.iss" @ONLY)
+endif()
+
 if(BUILD_OUT_OF_TREE)
-	# out of tree builds
-	# credits to c3r1c3
 	set(CMAKE_PREFIX_PATH "${QTDIR}")
 	set(CMAKE_INCLUDE_CURRENT_DIR ON)
 	list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/external")
@@ -16,99 +28,111 @@ if(BUILD_OUT_OF_TREE)
 	find_package(Libcurl REQUIRED)
 	find_path(LIBOBS_FRONTEND_INCLUDE_DIR HINTS ${LIBOBS_INCLUDE_DIRS})
 	find_file(LIBOBS_FRONTEND_API_LIB NAMES libobs-frontend-api.* HINTS ${LIBOBS_LIB} )
+endif()
 
-	if(APPLE)
-		find_library(COCOA Cocoa)
+if(APPLE)
+	find_library(COCOA Cocoa)
+	if(BUILD_OUT_OF_TREE)
 		find_package(Qt5MacExtras REQUIRED)
-		include_directories(${COCOA})
-		add_link_options("-v")
 	endif()
+	include_directories(${COCOA})
+endif()
 
-	if(UNIX AND NOT APPLE)
-		find_package(X11 REQUIRED)
-		link_libraries(${X11_LIBRARIES})
-		include_directories(${X11_INCLUDE_DIR})
-	endif()
 
-	set(advanced-scene-switcher_HEADERS
-		${advanced-scene-switcher_HEADERS}
-		src/headers/advanced-scene-switcher.hpp
-		src/headers/switcher-data-structs.hpp
-		src/headers/utility.hpp
-		src/headers/curl-helper.hpp
-		src/headers/switch-audio.hpp
-		src/headers/switch-executable.hpp
-		src/headers/switch-file.hpp
-		src/headers/switch-idle.hpp
-		src/headers/switch-media.hpp
-		src/headers/switch-random.hpp
-		src/headers/switch-screen-region.hpp
-		src/headers/switch-time.hpp
-		src/headers/switch-transitions.hpp
-		src/headers/switch-window.hpp
-		src/headers/swtich-sequence.hpp
-		src/headers/switch-generic.hpp
-		)
+if(UNIX AND NOT APPLE)
+	find_package(X11 REQUIRED)
+	link_libraries(${X11_LIBRARIES})
+	include_directories(${X11_INCLUDE_DIR})
+endif()
 
-	set(advanced-scene-switcher_SOURCES
-		${advanced-scene-switcher_SOURCES}
-		src/advanced-scene-switcher.cpp
-		src/advanced-scene-switcher-module.c
-		src/switcher-data-structs.cpp
-		src/switch-transitions.cpp
-		src/switch-screen-region.cpp
-		src/switch-priority.cpp
-		src/switch-executable.cpp
-		src/switch-idle.cpp
-		src/switch-sequence.cpp
-		src/switch-file.cpp
-		src/switch-window.cpp
-		src/switch-media.cpp
-		src/hotkey.cpp
-		src/general.cpp
-		src/switch-pause.cpp
-		src/switch-random.cpp
-		src/switch-time.cpp
-		src/switch-audio.cpp
-		src/curl-helper.cpp
-		)
+set(advanced-scene-switcher_HEADERS
+	${advanced-scene-switcher_HEADERS}
+	src/headers/advanced-scene-switcher.hpp
+	src/headers/switcher-data-structs.hpp
+	src/headers/utility.hpp
+	src/headers/curl-helper.hpp
+	src/headers/volume-control.hpp
+	src/headers/scene-group.hpp
+	src/headers/scene-trigger.hpp
+	src/headers/switch-audio.hpp
+	src/headers/switch-executable.hpp
+	src/headers/switch-file.hpp
+	src/headers/switch-idle.hpp
+	src/headers/switch-media.hpp
+	src/headers/switch-pause.hpp
+	src/headers/switch-random.hpp
+	src/headers/switch-screen-region.hpp
+	src/headers/switch-time.hpp
+	src/headers/switch-transitions.hpp
+	src/headers/switch-window.hpp
+	src/headers/switch-sequence.hpp
+	src/headers/switch-generic.hpp
+	src/headers/version.h
+	)
 
-	set(advanced-scene-switcher_UI
-		${advanced-scene-switcher_UI}
-		forms/advanced-scene-switcher.ui
-		)
+set(advanced-scene-switcher_SOURCES
+	${advanced-scene-switcher_SOURCES}
+	src/advanced-scene-switcher.cpp
+	src/advanced-scene-switcher-module.c
+	src/switcher-data-structs.cpp
+	src/scene-group.cpp
+	src/scene-trigger.cpp
+	src/switch-transitions.cpp
+	src/switch-screen-region.cpp
+	src/switch-priority.cpp
+	src/switch-executable.cpp
+	src/switch-idle.cpp
+	src/switch-sequence.cpp
+	src/switch-file.cpp
+	src/switch-window.cpp
+	src/switch-media.cpp
+	src/hotkey.cpp
+	src/general.cpp
+	src/switch-pause.cpp
+	src/switch-random.cpp
+	src/switch-time.cpp
+	src/switch-audio.cpp
+	src/switch-generic.cpp
+	src/curl-helper.cpp
+	src/volume-control.cpp
+	src/version.cpp
+	)
 
-	if(WIN32)
-		set(advanced-scene-switcher_PLATFORM_SOURCES
-			src/win/advanced-scene-switcher-win.cpp)
+set(advanced-scene-switcher_UI
+	${advanced-scene-switcher_UI}
+	forms/advanced-scene-switcher.ui
+	)
 
-	elseif(APPLE)
-		set(advanced-scene-switcher_PLATFORM_SOURCES
-			src/osx/advanced-scene-switcher-osx.mm)
-		set_source_files_properties(advanced-scene-switcher-osx.mm
-			PROPERTIES COMPILE_FLAGS "-fobjc-arc")
-		set(advanced-scene-switcher_PLATFORM_LIBS
-			${COCOA})
+if(WIN32)
+	set(advanced-scene-switcher_PLATFORM_SOURCES
+		src/win/advanced-scene-switcher-win.cpp)
+elseif(APPLE)
+	set(advanced-scene-switcher_PLATFORM_SOURCES
+		src/osx/advanced-scene-switcher-osx.mm)
+	set_source_files_properties(advanced-scene-switcher-osx.mm
+		PROPERTIES COMPILE_FLAGS "-fobjc-arc")
+	set(advanced-scene-switcher_PLATFORM_LIBS
+		${COCOA})
+else()
+	set(advanced-scene-switcher_PLATFORM_SOURCES
+		src/linux/advanced-scene-switcher-nix.cpp)
+	set(advanced-scene-switcher_PLATFORM_LIBS
+		Xss)
+endif()
 
-	elseif("${CMAKE_SYSTEM_NAME}" MATCHES "Linux")
-		set(advanced-scene-switcher_PLATFORM_SOURCES
-			src/linux/advanced-scene-switcher-nix.cpp)
-		set(advanced-scene-switcher_PLATFORM_LIBS
-			Xss)
-	endif()
+qt5_wrap_ui(advanced-scene-switcher_UI_HEADERS
+	${advanced-scene-switcher_UI}
+	${advanced-scene-switcher_PLATFORM_UI})
 
-	qt5_wrap_ui(advanced-scene-switcher_UI_HEADERS
-		${advanced-scene-switcher_UI}
-		${advanced-scene-switcher_PLATFORM_UI})
-
-	add_library(advanced-scene-switcher MODULE
-		${advanced-scene-switcher_HEADERS}
-		${advanced-scene-switcher_SOURCES}
-		${advanced-scene-switcher_UI_HEADERS}
-		${advanced-scene-switcher_PLATFORM_SOURCES}
-		${advanced-scene-switcher_PLATFORM_HEADERS}
-		)
+add_library(advanced-scene-switcher MODULE
+	${advanced-scene-switcher_HEADERS}
+	${advanced-scene-switcher_SOURCES}
+	${advanced-scene-switcher_UI_HEADERS}
+	${advanced-scene-switcher_PLATFORM_SOURCES}
+	${advanced-scene-switcher_PLATFORM_HEADERS}
+	)
 
+if(BUILD_OUT_OF_TREE)
 	include_directories(
 		"${LIBOBS_INCLUDE_DIRS}"
 		"${LIBOBS_FRONTEND_INCLUDE_DIR}"
@@ -144,7 +168,6 @@ if(BUILD_OUT_OF_TREE)
 	# OSX
 	if(APPLE)
 		set_target_properties(advanced-scene-switcher PROPERTIES PREFIX "")
-
 	endif()
 
 	# Linux
@@ -164,103 +187,12 @@ if(BUILD_OUT_OF_TREE)
 		install(FILES ${ASS_TRANSLATION_FILES}
 				DESTINATION "${CMAKE_INSTALL_PREFIX}/share/obs/obs-plugins/advanced-scene-switcher/locale")
 	endif()
-else ()
-	# in-tree build
-	if(APPLE)
-		find_library(COCOA Cocoa)
-		include_directories(${COCOA})
-	endif()
-
-	if(UNIX AND NOT APPLE)
-		find_package(X11 REQUIRED)
-		link_libraries(${X11_LIBRARIES})
-		include_directories(${X11_INCLUDE_DIR})
-	endif()
-
-	set(advanced-scene-switcher_HEADERS
-		${advanced-scene-switcher_HEADERS}
-		src/headers/advanced-scene-switcher.hpp
-		src/headers/switcher-data-structs.hpp
-		src/headers/utility.hpp
-		src/headers/curl-helper.hpp
-		src/headers/volume-control.hpp
-		src/headers/switch-audio.hpp
-		src/headers/switch-executable.hpp
-		src/headers/switch-file.hpp
-		src/headers/switch-idle.hpp
-		src/headers/switch-media.hpp
-		src/headers/switch-random.hpp
-		src/headers/switch-screen-region.hpp
-		src/headers/switch-time.hpp
-		src/headers/switch-transitions.hpp
-		src/headers/switch-window.hpp
-		src/headers/swtich-sequence.hpp
-		src/headers/switch-generic.hpp
-		)
-
-	set(advanced-scene-switcher_SOURCES
-		${advanced-scene-switcher_SOURCES}
-		src/advanced-scene-switcher.cpp
-		src/advanced-scene-switcher-module.c
-		src/switcher-data-structs.cpp
-		src/switch-transitions.cpp
-		src/switch-screen-region.cpp
-		src/switch-priority.cpp
-		src/switch-executable.cpp
-		src/switch-idle.cpp
-		src/switch-sequence.cpp
-		src/switch-file.cpp
-		src/switch-window.cpp
-		src/switch-media.cpp
-		src/hotkey.cpp
-		src/general.cpp
-		src/switch-pause.cpp
-		src/switch-random.cpp
-		src/switch-time.cpp
-		src/switch-audio.cpp
-		src/curl-helper.cpp
-		src/volume-control.cpp
-		)
-
-	set(advanced-scene-switcher_UI
-		${advanced-scene-switcher_UI}
-		forms/advanced-scene-switcher.ui
-		)
-
-	if(WIN32)
-		set(advanced-scene-switcher_PLATFORM_SOURCES
-			src/win/advanced-scene-switcher-win.cpp)
-	elseif(APPLE)
-		set(advanced-scene-switcher_PLATFORM_SOURCES
-			src/osx/advanced-scene-switcher-osx.mm)
-		set_source_files_properties(advanced-scene-switcher-osx.mm
-			PROPERTIES COMPILE_FLAGS "-fobjc-arc")
-		set(advanced-scene-switcher_PLATFORM_LIBS
-			${COCOA})
-	else()
-		set(advanced-scene-switcher_PLATFORM_SOURCES
-			src/linux/advanced-scene-switcher-nix.cpp)
-		set(advanced-scene-switcher_PLATFORM_LIBS
-			Xss)
-	endif()
-
-	qt5_wrap_ui(advanced-scene-switcher_UI_HEADERS
-		${advanced-scene-switcher_UI}
-		${advanced-scene-switcher_PLATFORM_UI})
-
-	add_library(advanced-scene-switcher MODULE
-		${advanced-scene-switcher_HEADERS}
-		${advanced-scene-switcher_SOURCES}
-		${advanced-scene-switcher_UI_HEADERS}
-		${advanced-scene-switcher_PLATFORM_SOURCES}
-		${advanced-scene-switcher_PLATFORM_HEADERS}
-		)
-
+else()
 	target_link_libraries(advanced-scene-switcher
 		${advanced-scene-switcher_PLATFORM_LIBS}
 		obs-frontend-api
 		Qt5::Widgets
 		libobs)
 
-	install_obs_plugin(advanced-scene-switcher data)
+	install_obs_plugin_with_data(advanced-scene-switcher data)
 endif()

README.md

@@ -3,7 +3,7 @@ An automated scene switcher for OBS Studio
 
 More information can be found on https://obsproject.com/forum/resources/automatic-scene-switching.395/
 
-## Compiling in tree
+## Compiling in tree (recommended)
 Add the "SceneSwitcher" source directory to your obs-studio source directory under obs-studio/UI/frontend-plugins/:
 ```
 cd obs-studio/UI/frontend-plugins/
@@ -49,9 +49,10 @@ Most versions of Linux you can use cmake-gui or the command line.
 
 **For the command line:**  
 ```
-cmake -DBUILD_OUT_OF_TREE=1 -DLIBOBS_INCLUDE_DIR="<path to the libobs/ sub-folder in obs-studio's source code>"
--DLIBOBS_FRONTEND_INCLUDE_DIR="<path to the UI/obs-frontend-api/ sub-folder in obs-studio's source code>"
--DLIBOBS_FRONTEND_API_LIB="< path to the libobs-frontend-api.so file (usually in the same place as LIBOBS_LIB)>"
+cmake -DBUILD_OUT_OF_TREE=1 -DLIBOBS_INCLUDE_DIR="<path to the libobs/ sub-folder in obs-studio's source code>" \
+-DLIBOBS_FRONTEND_INCLUDE_DIR="<path to the UI/obs-frontend-api/ sub-folder in obs-studio's source code>" \
+-DLIBOBS_LIB="<path to the libobs.so file>" \
+-DLIBOBS_FRONTEND_API_LIB="<path to the libobs-frontend-api.so file (usually in the same place as LIBOBS_LIB)>" \
 -DCMAKE_INSTALL_PREFIX=/usr ..
 make -j4
 sudo make install

cmake/GetGitRevisionDescription.cmake

@@ -0,0 +1,279 @@
+# - Returns a version string from Git
+#
+# These functions force a re-configure on each git commit so that you can
+# trust the values of the variables in your build system.
+#
+#  get_git_head_revision(<refspecvar> <hashvar> [<additional arguments to git describe> ...])
+#
+# Returns the refspec and sha hash of the current head revision
+#
+#  git_describe(<var> [<additional arguments to git describe> ...])
+#
+# Returns the results of git describe on the source tree, and adjusting
+# the output so that it tests false if an error occurs.
+#
+#  git_describe_working_tree(<var> [<additional arguments to git describe> ...])
+#
+# Returns the results of git describe on the working tree (--dirty option),
+# and adjusting the output so that it tests false if an error occurs.
+#
+#  git_get_exact_tag(<var> [<additional arguments to git describe> ...])
+#
+# Returns the results of git describe --exact-match on the source tree,
+# and adjusting the output so that it tests false if there was no exact
+# matching tag.
+#
+#  git_local_changes(<var>)
+#
+# Returns either "CLEAN" or "DIRTY" with respect to uncommitted changes.
+# Uses the return code of "git diff-index --quiet HEAD --".
+# Does not regard untracked files.
+#
+# Requires CMake 2.6 or newer (uses the 'function' command)
+#
+# Original Author:
+# 2009-2020 Ryan Pavlik <ryan.pavlik@gmail.com> <abiryan@ryand.net>
+# http://academic.cleardefinition.com
+#
+# Copyright 2009-2013, Iowa State University.
+# Copyright 2013-2020, Ryan Pavlik
+# Copyright 2013-2020, Contributors
+# SPDX-License-Identifier: BSL-1.0
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+if(__get_git_revision_description)
+    return()
+endif()
+set(__get_git_revision_description YES)
+
+# We must run the following at "include" time, not at function call time,
+# to find the path to this module rather than the path to a calling list file
+get_filename_component(_gitdescmoddir ${CMAKE_CURRENT_LIST_FILE} PATH)
+
+# Function _git_find_closest_git_dir finds the next closest .git directory
+# that is part of any directory in the path defined by _start_dir.
+# The result is returned in the parent scope variable whose name is passed
+# as variable _git_dir_var. If no .git directory can be found, the
+# function returns an empty string via _git_dir_var.
+#
+# Example: Given a path C:/bla/foo/bar and assuming C:/bla/.git exists and
+# neither foo nor bar contain a file/directory .git. This wil return
+# C:/bla/.git
+#
+function(_git_find_closest_git_dir _start_dir _git_dir_var)
+    set(cur_dir "${_start_dir}")
+    set(git_dir "${_start_dir}/.git")
+    while(NOT EXISTS "${git_dir}")
+        # .git dir not found, search parent directories
+        set(git_previous_parent "${cur_dir}")
+        get_filename_component(cur_dir ${cur_dir} DIRECTORY)
+        if(cur_dir STREQUAL git_previous_parent)
+            # We have reached the root directory, we are not in git
+            set(${_git_dir_var}
+                ""
+                PARENT_SCOPE)
+            return()
+        endif()
+        set(git_dir "${cur_dir}/.git")
+    endwhile()
+    set(${_git_dir_var}
+        "${git_dir}"
+        PARENT_SCOPE)
+endfunction()
+
+function(get_git_head_revision _refspecvar _hashvar)
+    _git_find_closest_git_dir("${CMAKE_CURRENT_SOURCE_DIR}" GIT_DIR)
+
+    if(NOT "${GIT_DIR}" STREQUAL "")
+        file(RELATIVE_PATH _relative_to_source_dir "${CMAKE_SOURCE_DIR}"
+             "${GIT_DIR}")
+        if("${_relative_to_source_dir}" MATCHES "[.][.]")
+            # We've gone above the CMake root dir.
+            set(GIT_DIR "")
+        endif()
+    endif()
+    if("${GIT_DIR}" STREQUAL "")
+        set(${_refspecvar}
+            "GITDIR-NOTFOUND"
+            PARENT_SCOPE)
+        set(${_hashvar}
+            "GITDIR-NOTFOUND"
+            PARENT_SCOPE)
+        return()
+    endif()
+
+    # Check if the current source dir is a git submodule or a worktree.
+    # In both cases .git is a file instead of a directory.
+    #
+    if(NOT IS_DIRECTORY ${GIT_DIR})
+        # The following git command will return a non empty string that
+        # points to the super project working tree if the current
+        # source dir is inside a git submodule.
+        # Otherwise the command will return an empty string.
+        #
+        execute_process(
+            COMMAND "${GIT_EXECUTABLE}" rev-parse
+                    --show-superproject-working-tree
+            WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+            OUTPUT_VARIABLE out
+            ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+        if(NOT "${out}" STREQUAL "")
+            # If out is empty, GIT_DIR/CMAKE_CURRENT_SOURCE_DIR is in a submodule
+            file(READ ${GIT_DIR} submodule)
+            string(REGEX REPLACE "gitdir: (.*)$" "\\1" GIT_DIR_RELATIVE
+                                 ${submodule})
+            string(STRIP ${GIT_DIR_RELATIVE} GIT_DIR_RELATIVE)
+            get_filename_component(SUBMODULE_DIR ${GIT_DIR} PATH)
+            get_filename_component(GIT_DIR ${SUBMODULE_DIR}/${GIT_DIR_RELATIVE}
+                                   ABSOLUTE)
+            set(HEAD_SOURCE_FILE "${GIT_DIR}/HEAD")
+        else()
+            # GIT_DIR/CMAKE_CURRENT_SOURCE_DIR is in a worktree
+            file(READ ${GIT_DIR} worktree_ref)
+            # The .git directory contains a path to the worktree information directory
+            # inside the parent git repo of the worktree.
+            #
+            string(REGEX REPLACE "gitdir: (.*)$" "\\1" git_worktree_dir
+                                 ${worktree_ref})
+            string(STRIP ${git_worktree_dir} git_worktree_dir)
+            _git_find_closest_git_dir("${git_worktree_dir}" GIT_DIR)
+            set(HEAD_SOURCE_FILE "${git_worktree_dir}/HEAD")
+        endif()
+    else()
+        set(HEAD_SOURCE_FILE "${GIT_DIR}/HEAD")
+    endif()
+    set(GIT_DATA "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/git-data")
+    if(NOT EXISTS "${GIT_DATA}")
+        file(MAKE_DIRECTORY "${GIT_DATA}")
+    endif()
+
+    if(NOT EXISTS "${HEAD_SOURCE_FILE}")
+        return()
+    endif()
+    set(HEAD_FILE "${GIT_DATA}/HEAD")
+    configure_file("${HEAD_SOURCE_FILE}" "${HEAD_FILE}" COPYONLY)
+
+    configure_file("${_gitdescmoddir}/GetGitRevisionDescription.cmake.in"
+                   "${GIT_DATA}/grabRef.cmake" @ONLY)
+    include("${GIT_DATA}/grabRef.cmake")
+
+    set(${_refspecvar}
+        "${HEAD_REF}"
+        PARENT_SCOPE)
+    set(${_hashvar}
+        "${HEAD_HASH}"
+        PARENT_SCOPE)
+endfunction()
+
+function(git_describe _var)
+    if(NOT GIT_FOUND)
+        find_package(Git QUIET)
+    endif()
+    get_git_head_revision(refspec hash)
+    if(NOT GIT_FOUND)
+        set(${_var}
+            "GIT-NOTFOUND"
+            PARENT_SCOPE)
+        return()
+    endif()
+    if(NOT hash)
+        set(${_var}
+            "HEAD-HASH-NOTFOUND"
+            PARENT_SCOPE)
+        return()
+    endif()
+
+    # TODO sanitize
+    #if((${ARGN}" MATCHES "&&") OR
+    #	(ARGN MATCHES "||") OR
+    #	(ARGN MATCHES "\\;"))
+    #	message("Please report the following error to the project!")
+    #	message(FATAL_ERROR "Looks like someone's doing something nefarious with git_describe! Passed arguments ${ARGN}")
+    #endif()
+
+    #message(STATUS "Arguments to execute_process: ${ARGN}")
+
+    execute_process(
+        COMMAND "${GIT_EXECUTABLE}" describe --tags --always ${hash} ${ARGN}
+        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+        RESULT_VARIABLE res
+        OUTPUT_VARIABLE out
+        ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+    if(NOT res EQUAL 0)
+        set(out "${out}-${res}-NOTFOUND")
+    endif()
+
+    set(${_var}
+        "${out}"
+        PARENT_SCOPE)
+endfunction()
+
+function(git_describe_working_tree _var)
+    if(NOT GIT_FOUND)
+        find_package(Git QUIET)
+    endif()
+    if(NOT GIT_FOUND)
+        set(${_var}
+            "GIT-NOTFOUND"
+            PARENT_SCOPE)
+        return()
+    endif()
+
+    execute_process(
+        COMMAND "${GIT_EXECUTABLE}" describe --dirty ${ARGN}
+        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+        RESULT_VARIABLE res
+        OUTPUT_VARIABLE out
+        ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+    if(NOT res EQUAL 0)
+        set(out "${out}-${res}-NOTFOUND")
+    endif()
+
+    set(${_var}
+        "${out}"
+        PARENT_SCOPE)
+endfunction()
+
+function(git_get_exact_tag _var)
+    git_describe(out --exact-match ${ARGN})
+    set(${_var}
+        "${out}"
+        PARENT_SCOPE)
+endfunction()
+
+function(git_local_changes _var)
+    if(NOT GIT_FOUND)
+        find_package(Git QUIET)
+    endif()
+    get_git_head_revision(refspec hash)
+    if(NOT GIT_FOUND)
+        set(${_var}
+            "GIT-NOTFOUND"
+            PARENT_SCOPE)
+        return()
+    endif()
+    if(NOT hash)
+        set(${_var}
+            "HEAD-HASH-NOTFOUND"
+            PARENT_SCOPE)
+        return()
+    endif()
+
+    execute_process(
+        COMMAND "${GIT_EXECUTABLE}" diff-index --quiet HEAD --
+        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+        RESULT_VARIABLE res
+        OUTPUT_VARIABLE out
+        ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+    if(res EQUAL 0)
+        set(${_var}
+            "CLEAN"
+            PARENT_SCOPE)
+    else()
+        set(${_var}
+            "DIRTY"
+            PARENT_SCOPE)
+    endif()
+endfunction()

cmake/GetGitRevisionDescription.cmake.in

@@ -0,0 +1,41 @@
+#
+# Internal file for GetGitRevisionDescription.cmake
+#
+# Requires CMake 2.6 or newer (uses the 'function' command)
+#
+# Original Author:
+# 2009-2010 Ryan Pavlik <rpavlik@iastate.edu> <abiryan@ryand.net>
+# http://academic.cleardefinition.com
+# Iowa State University HCI Graduate Program/VRAC
+#
+# Copyright Iowa State University 2009-2010.
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+set(HEAD_HASH)
+
+file(READ "@HEAD_FILE@" HEAD_CONTENTS LIMIT 1024)
+
+string(STRIP "${HEAD_CONTENTS}" HEAD_CONTENTS)
+if(HEAD_CONTENTS MATCHES "ref")
+	# named branch
+	string(REPLACE "ref: " "" HEAD_REF "${HEAD_CONTENTS}")
+	if(EXISTS "@GIT_DIR@/${HEAD_REF}")
+		configure_file("@GIT_DIR@/${HEAD_REF}" "@GIT_DATA@/head-ref" COPYONLY)
+	else()
+		configure_file("@GIT_DIR@/packed-refs" "@GIT_DATA@/packed-refs" COPYONLY)
+		file(READ "@GIT_DATA@/packed-refs" PACKED_REFS)
+		if(${PACKED_REFS} MATCHES "([0-9a-z]*) ${HEAD_REF}")
+			set(HEAD_HASH "${CMAKE_MATCH_1}")
+		endif()
+	endif()
+else()
+	# detached HEAD
+	configure_file("@GIT_DIR@/HEAD" "@GIT_DATA@/head-ref" COPYONLY)
+endif()
+
+if(NOT HEAD_HASH)
+	file(READ "@GIT_DATA@/head-ref" HEAD_HASH LIMIT 1024)
+	string(STRIP "${HEAD_HASH}" HEAD_HASH)
+endif()

cmake/version.cpp.in

@@ -0,0 +1,3 @@
+#include "src/headers/version.h"
+#define GIT_SHA1 "@GIT_SHA1@"
+const char g_GIT_SHA1[] = GIT_SHA1;

data/locale/de-DE.ini

@@ -0,0 +1,268 @@
+AdvSceneSwitcher.pluginName="Erweiterter Automatischer Szenenwechsler"
+AdvSceneSwitcher.windowTitle="Erweiterter Automatischer Szenenwechsler"
+
+; General Tab
+AdvSceneSwitcher.generalTab.title="Allgemein"
+AdvSceneSwitcher.generalTab.status="Status"
+AdvSceneSwitcher.generalTab.status.hotkeytips="Hotkeys können in den OBS Einstellungen konfiguriert werden"
+AdvSceneSwitcher.generalTab.status.currentStatus="Erweiterter Automatischer Szenenwechsler ist:"
+AdvSceneSwitcher.generalTab.status.onStartup="Beim Start von OBS:"
+AdvSceneSwitcher.generalTab.status.onStartup.asLastRun="Aktiviere den Szenenwechsler wenn er aktiv war"
+AdvSceneSwitcher.generalTab.status.onStartup.alwaysStart="Aktiviere den Szenenwechsler"
+AdvSceneSwitcher.generalTab.status.onStartup.doNotStart="Aktiviere den Szenenwechsler nicht"
+AdvSceneSwitcher.generalTab.status.start="Start"
+AdvSceneSwitcher.generalTab.status.stop="Stop"
+AdvSceneSwitcher.generalTab.status.autoStart="Starte auotmatischen den Szenenwechsler beim:"
+AdvSceneSwitcher.generalTab.status.autoStart.never="Niemals"
+AdvSceneSwitcher.generalTab.status.autoStart.recording="Aufnehmen"
+AdvSceneSwitcher.generalTab.status.autoStart.streaming="Streamen"
+AdvSceneSwitcher.generalTab.status.autoStart.recordingAndStreaming="Aufnehmen oder Streamen"
+AdvSceneSwitcher.generalTab.status.checkInterval="Teste Bedingungen alle"
+AdvSceneSwitcher.generalTab.generalBehavior="Allgemeines Verhalten"
+AdvSceneSwitcher.generalTab.generalBehavior.onNoMet="Wenn keine Bedingung erfüllt ist für "
+AdvSceneSwitcher.generalTab.generalBehavior.onNoMetDelayTooltip="Kann nur so genau sein wie das eingestellte Interval zum Testen der Bedingungen."
+AdvSceneSwitcher.generalTab.generalBehavior.onNoMet.dontSwitch="Nicht wechseln"
+AdvSceneSwitcher.generalTab.generalBehavior.onNoMet.switchToRandom="Wechsle zu einer Szene auf dem Zufall-Tab"
+AdvSceneSwitcher.generalTab.generalBehavior.onNoMet.switchTo="Wechsle zu:"
+AdvSceneSwitcher.generalTab.generalBehavior.cooldown="Nach einem automatisierten Szenenwechsel wechsle nicht mehr für"
+AdvSceneSwitcher.generalTab.generalBehavior.cooldownHint="In diesem Zeitraum werden potentielle erfüllte Bedingungen ignoriert!"
+AdvSceneSwitcher.generalTab.generalBehavior.verboseLogging="Ausführliches Logging"
+AdvSceneSwitcher.generalTab.generalBehavior.disableUIHints="Deaktiviere UI Tipps"
+AdvSceneSwitcher.generalTab.priority="Priorität"
+AdvSceneSwitcher.generalTab.priority.description="Szenenwechselmethoden sortiert nach Priorität"
+AdvSceneSwitcher.generalTab.priority.threadPriority="Benutze Thread Priorität"
+AdvSceneSwitcher.generalTab.priority.threadPriorityNotice="(Erhöhen der Priorität über \"Normal\" ist nicht empfohlen)"
+AdvSceneSwitcher.generalTab.saveOrLoadsettings="Speichern / Laden der Einstellungen"
+AdvSceneSwitcher.generalTab.saveOrLoadsettings.export="Exportieren"
+AdvSceneSwitcher.generalTab.saveOrLoadsettings.import="Importieren"
+AdvSceneSwitcher.generalTab.saveOrLoadsettings.exportWindowTitle="Exportiere Erweiterter Automatischer Szenenwechsler Einstellungen zu Datei ..."
+AdvSceneSwitcher.generalTab.saveOrLoadsettings.importWindowTitle="Exportiere Erweiterter Automatischer Szenenwechsler Einstellungen von Datei ..."
+AdvSceneSwitcher.generalTab.saveOrLoadsettings.textType="Text Dateien (*.txt)"
+AdvSceneSwitcher.generalTab.saveOrLoadsettings.loadFail="Importieren der Einstellungen ist fehlgeschlagen"
+AdvSceneSwitcher.generalTab.saveOrLoadsettings.loadSuccess="Einstellungen wurden erfolgreich importiert"
+AdvSceneSwitcher.generalTab.priority.fileContent="Datei Inhalt"
+AdvSceneSwitcher.generalTab.priority.sceneSequence="Szenenfolge"
+AdvSceneSwitcher.generalTab.priority.idleDetection="Inaktivitätserkennung"
+AdvSceneSwitcher.generalTab.priority.executable="Prozess"
+AdvSceneSwitcher.generalTab.priority.screenRegion="Bildschrimbereich"
+AdvSceneSwitcher.generalTab.priority.windowTitle="Fenstername"
+AdvSceneSwitcher.generalTab.priority.media="Medien"
+AdvSceneSwitcher.generalTab.priority.time="Zeit"
+AdvSceneSwitcher.generalTab.priority.audio="Audio"
+
+; Transition Tab
+AdvSceneSwitcher.transitionTab.title="Szenenübergänge"
+AdvSceneSwitcher.transitionTab.transitionOverride="Szenenübergänge, die im Szenenwechsler konfiguriert werden, haben Vorrang vor Übergangsüberschreibung"
+AdvSceneSwitcher.transitionTab.transitionForAToB="Szenenübergänge für automatisierte Szenenwechsel von Szene A zu Szene B"
+AdvSceneSwitcher.transitionTab.transitionsHelp="<html><head/><body><p>Diese Einstellungen beeinflussen <span style=\"font-style:italic;\">nur</span> vom Szenenwechsler ausgelöste Szenenübergänge - Siehe <a href=\"https://obsproject.com/forum/resources/transition-table.1174/\"><span style=\" text-decoration: underline; color:#268bd2;\">Transition Table</span></a> um auch manuelle Szenenübergänge zu konfigurieren.<br/>Einstellungen auf diesem Tab haben Vorrang, vor denen welche auf den übrigen Tabs konfiguriert wurden.<br/><br/>Klicke auf das Plus Symbol, um einen neuen Eintrag hinzuzufügen.</p></body></html>"
+AdvSceneSwitcher.transitionTab.defaultTransition="Ändere den Szenenübergang wenn eine Szene aktiv ist"
+AdvSceneSwitcher.transitionTab.entry="Wechsle von {{scenes}} zu {{scenes2}} mit {{transitions}}"
+AdvSceneSwitcher.transitionTab.defaultTransitionEntry="Wenn {{scenes}} aktiv ist ändere den Szenenübergang zu {{transitions}}"
+AdvSceneSwitcher.transitionTab.defaultTransitionsHelp="Klicke auf das Plus Symbol, um einen neuen Eintrag hinzuzufügen."
+
+; Pause Scenes Tab
+AdvSceneSwitcher.pauseTab.title="Pause"
+AdvSceneSwitcher.pauseTab.pauseOnScene="Pausiere den Szenenwechsler auf einer Szene"
+AdvSceneSwitcher.pauseTab.pauseInFocus1="Pausiere den Szenenwechsler wenn "
+AdvSceneSwitcher.pauseTab.pauseInFocus2="im Fokus ist"
+AdvSceneSwitcher.pauseTab.pauseTypeScene="Szene aktiv ist"
+AdvSceneSwitcher.pauseTab.pauseTypeWindow="Fenster im Fokus ist"
+AdvSceneSwitcher.pauseTab.pauseTargetAll="alle"
+AdvSceneSwitcher.pauseTab.pauseEntry="Pausiere {{pauseTargets}} Überprüfungen wenn {{scenes}} {{windows}} {{pauseTypes}}"
+AdvSceneSwitcher.pauseTab.help="Auf diesem Tab können einzelne Szenenwechselmethoden pausiert werden, wenn eine Szene aktiv oder ein Fenster im Fokus ist.\n\nKlicke auf das markierte Plus Symbol, um einen neuen Eintrag hinzuzufügen."
+
+; Window Title Tab
+AdvSceneSwitcher.windowTitleTab.title="Fenstername"
+AdvSceneSwitcher.windowTitleTab.regexrDescription="<html><head/><body><p>Gib entweder den gesamten Fensternamen ein oder eine gültigen regulären Ausdruck. Die Syntax für regulärer Ausdrücke (regex) kann hier überprüft werden: <a href=\"https://regexr.com\"><span style=\" text-decoration: underline; color:#268bd2;\">RegExr</span></a></p></body></html>"
+AdvSceneSwitcher.windowTitleTab.stayInFocus1="Ignoriere diesen Fensternamen"
+AdvSceneSwitcher.windowTitleTab.stayInFocus2=" "
+AdvSceneSwitcher.windowTitleTab.fullscreen="wenn Vollbild"
+AdvSceneSwitcher.windowTitleTab.maximized="wenn maximiert"
+AdvSceneSwitcher.windowTitleTab.focused="wenn fokussiert"
+AdvSceneSwitcher.windowTitleTab.entry="{{windows}} {{scenes}} {{transitions}} {{fullscreen}} {{maximized}} {{focused}}"
+AdvSceneSwitcher.windowTitleTab.windowsHelp="Wechsle Szenen basiert auf dem Fensternamen eines laufenden Prozesses.\nFolgende zusätzliche Bedingungen können ausgewählt werden:\nDas Fenster ist im Vollbildmodus\nDas Fenster ist maximiert\nDas Fenster ist fokussiert\n\nKlicke auf das markierte Plus Symbol, um einen neuen Eintrag hinzuzufügen."
+AdvSceneSwitcher.windowTitleTab.ignoreWindowsHelp="Ist ein Fenstername ignoriert so verhält sich der Szenenwechsler als ob das vorhergehende Fenster immer noch fokussiert ist.\nDies kann in Situationen nützlich sein, in den oft zwischen Fenster gewechselt wird, dies aber nicht immer einen Szenenwechsel auslösen soll.\n\nWähle oben ein Fenster aus oder gib einen Fensternamen ein und klicke auf das Plus Symbol um es zur Liste hinzuzufügen."
+
+; Executable Tab
+AdvSceneSwitcher.executableTab.title="Prozess"
+AdvSceneSwitcher.executableTab.implemented="Implementiert von dasOven"
+AdvSceneSwitcher.executableTab.requiresFocus="nur wenn dieser fokussiert ist"
+AdvSceneSwitcher.executableTab.entry="Wenn {{processes}} läuft wechsle zu {{scenes}} mit {{transitions}} {{requiresFocus}}"
+AdvSceneSwitcher.executableTab.help="Dieser Tab erlaubt es Szenen zu wechseln, wenn bestimmte Prozesse laufen.\nDas kann nützlich sein, wenn sich der Name eines Fensters ändern kann oder dieser nicht bekannt ist.\n\nKlicke auf das markierte Plus Symbol, um einen neuen Eintrag hinzuzufügen."
+
+; Screen Region Tab
+AdvSceneSwitcher.screenRegionTab.title="Bildschrimbereich"
+AdvSceneSwitcher.screenRegionTab.currentPosition="Mauszeiger ist bei:"
+AdvSceneSwitcher.screenRegionTab.showGuideFrames="Hilfsrahmen einblenden"
+AdvSceneSwitcher.screenRegionTab.hideGuideFrames="Hilfsrahmen ausblenden"
+AdvSceneSwitcher.screenRegionTab.excludeScenes.None="Keine Auswahl"
+AdvSceneSwitcher.screenRegionTab.entry="Wenn der Mauszeiger in {{minX}} {{minY}} x {{maxX}} {{maxY}} ist wechsle zu {{scenes}} mit {{transitions}} außer wenn auf {{excludeScenes}}"
+AdvSceneSwitcher.screenRegionTab.help="Dieser Tab ermöglicht es basierend auf der Position des Mauszeigers Szenen zu wechseln.\n\nKlicke auf das markierte Plus Symbol, um einen neuen Eintrag hinzuzufügen."
+
+; Media Tab
+AdvSceneSwitcher.mediaTab.title="Medien"
+AdvSceneSwitcher.mediaTab.implemented="Implementiert von Exeldro"
+AdvSceneSwitcher.mediaTab.states.none="Keine Auswahl"
+AdvSceneSwitcher.mediaTab.states.playing="Abspielen"
+AdvSceneSwitcher.mediaTab.states.opening="Öffnen"
+AdvSceneSwitcher.mediaTab.states.buffering="Buffern"
+AdvSceneSwitcher.mediaTab.states.Paused="Pausiert"
+AdvSceneSwitcher.mediaTab.states.stopped="Gestoppt"
+AdvSceneSwitcher.mediaTab.states.ended="Beendet"
+AdvSceneSwitcher.mediaTab.states.error="Fehler"
+AdvSceneSwitcher.mediaTab.states.playedToEnd="Zu Ende gespielt"
+AdvSceneSwitcher.mediaTab.states.any="Beliebig"
+AdvSceneSwitcher.mediaTab.timeRestriction.none="Keine Auswahl"
+AdvSceneSwitcher.mediaTab.timeRestriction.shorter="Dauer kürzer"
+AdvSceneSwitcher.mediaTab.timeRestriction.longer="Dauer länger"
+AdvSceneSwitcher.mediaTab.timeRestriction.remainShorter="übrige Zeit kürzer"
+AdvSceneSwitcher.mediaTab.timeRestriction.remainLonger="übrige Zeit länger"
+AdvSceneSwitcher.mediaTab.entry="Wenn {{mediaSources}} im Status {{states}} ist und{{timeRestrictions}} {{time}} ist wechsle zu {{scenes}} mit {{transitions}}"
+AdvSceneSwitcher.mediaTab.help="Dieser Tab ermöglicht es basieren auf dem Status von Medienquellen Szenen zu wechseln.\nZum Beispiel kann automatisch zur vorhergehenden Szene gewechselt werden, sobald sich eine Medienquelle im Status Beendet befindet.\n\nKlicke auf das markierte Plus Symbol, um einen neuen Eintrag hinzuzufügen."
+
+; File Tab
+AdvSceneSwitcher.fileTab.title="Datei Inhalt"
+AdvSceneSwitcher.fileTab.readWriteSceneFile="Lese / schreibe Szene von / zu Datei"
+AdvSceneSwitcher.fileTab.currentSceneOutputFile="Schreibe den Namen der aktiven Szene in folgende Datei:"
+AdvSceneSwitcher.fileTab.switchSceneBaseOnFile="Aktiviere Lesen der Szene aus Datei"
+AdvSceneSwitcher.fileTab.switchSceneNameInputFile="Lies den Namen der Scene zu der gewechselt werden soll von folgender Datei:"
+AdvSceneSwitcher.fileTab.switchSceneBaseOnFileContent="Wechsle Scene basierend auf Datei Inhalt"
+AdvSceneSwitcher.fileTab.remoteFileWarning="Vorsicht: Der Szenenwechsler wird versuchen den angegebenen Pfad alle x ms zu öffnen!"
+AdvSceneSwitcher.fileTab.remoteFileWarning1="Vorsicht: Der Szenenwechsler öffnet den angegebenen Pfad alle "
+AdvSceneSwitcher.fileTab.remoteFileWarning2="ms"
+AdvSceneSwitcher.fileTab.libcurlWarning="Laden von libcurl fehlgeschlagen! Erreichen von remote Dateien wird nicht möglich sein!"
+AdvSceneSwitcher.fileTab.selectWrite=Datei auswählen in die geschrieben werden soll ..."
+AdvSceneSwitcher.fileTab.selectRead="Datei auswählen die gelesen werden soll ..."
+AdvSceneSwitcher.fileTab.textFileType="Text Dateien (*.txt)"
+AdvSceneSwitcher.fileTab.anyFileType="Beliebige Dateien (*.*)"
+AdvSceneSwitcher.fileTab.remote="remote Datei"
+AdvSceneSwitcher.fileTab.local="lokale Datei"
+AdvSceneSwitcher.fileTab.useRegExp="verwende reguläre Ausdrücke"
+AdvSceneSwitcher.fileTab.checkfileContentTime="nur wenn sich das Änderungsdatum geändert"
+AdvSceneSwitcher.fileTab.checkfileContent="nur wenn sich der Inhalt geänder hat"
+AdvSceneSwitcher.fileTab.entry="Wechsle zu {{scenes}} mit {{transitions}} wenn der Inhalt von {{fileType}} {{filePath}} {{browseButton}} passt zu:"
+AdvSceneSwitcher.fileTab.entry2="{{matchText}}"
+AdvSceneSwitcher.fileTab.entry3="{{useRegex}} {{checkModificationDate}} {{checkFileContent}}"
+AdvSceneSwitcher.fileTab.help="Dieser Tab erlaubt es Szenen zu wechseln basierend auf dem Inhalt von lokalen oder remote Dateien.\n\nKlicke auf das markierte Plus Symbol, um einen neuen Eintrag hinzuzufügen."
+
+; Random Tab
+AdvSceneSwitcher.randomTab.title="Zufall"
+AdvSceneSwitcher.randomTab.randomDisabledWarning="Funktionalität deaktiviert - Um diese zu aktivieren wähle \"Wenn keine Bedingung erfüllt ist wechsle zu einer Szene auf dem Zufall-Tab\" auf dem Allgemein-Tab aus"
+AdvSceneSwitcher.randomTab.entry="Wenn keine Bedingung erfüllt ist wechsle zu {{scenes}} mit {{transitions}} für {{delay}}"
+AdvSceneSwitcher.randomTab.help="Der Szenenwechsler wählt zufällig einen Eintrag auf diesem Tab aus, zu dem er für die angegebene Zeit wechseln wird.\nDer gleiche Eintrag wird nicht zweimal nacheinander ausgewählt werden.\n\nKlicke auf das markierte Plus Symbol, um einen neuen Eintrag hinzuzufügen."
+
+; Time Tab
+AdvSceneSwitcher.timeTab.title="Zeit"
+AdvSceneSwitcher.timeTab.anyDay="An allen Tagen"
+AdvSceneSwitcher.timeTab.mondays="Montags"
+AdvSceneSwitcher.timeTab.tuesdays="Dienstags"
+AdvSceneSwitcher.timeTab.wednesdays="Mittwochs"
+AdvSceneSwitcher.timeTab.thursdays="Donnerstags"
+AdvSceneSwitcher.timeTab.fridays="Freitags"
+AdvSceneSwitcher.timeTab.saturdays="Samstags"
+AdvSceneSwitcher.timeTab.sundays="Sonntags"
+AdvSceneSwitcher.timeTab.afterstart="Nach Streamen-/Aufnehmenstart"
+AdvSceneSwitcher.timeTab.afterstart.tip="Hier wird die Zeit relativ zum Starten des Streamen/Aufnehmen gemessen"
+AdvSceneSwitcher.timeTab.entry="{{triggers}} um {{time}} wechsle zu {{scenes}} mit {{transitions}}"
+AdvSceneSwitcher.timeTab.help="Dieser Tab ermöglicht es Szenen basierend auf der aktuellen Uhrzeit zu wechseln.\n\nDer Szenenwechsler versucht den Szenenwechsel nur zur eingestellten Uhrzeit auszulösen.\nBeachte, dass die Prioritätseinstellungen auf dem Allgemein Tab entsprechend konfiguriert sind, sodass keine andere Szenenwechselmethode hier konfiguriert Einstellungen zur gegebenen Uhrzeit übertrifft.\n\nKlicke auf das markierte Plus Symbol, um einen neuen Eintrag hinzuzufügen."
+
+; Idle Tab
+AdvSceneSwitcher.idleTab.title="Inaktivitätserkennung"
+AdvSceneSwitcher.idleTab.enable="Aktiviere Inaktivitätserkennung"
+AdvSceneSwitcher.idleTab.idleswitch="After {{duration}} ohne Keyboard- oder Mauseingaben wechsle zu {{scenes}} mit {{transitions}}"
+AdvSceneSwitcher.idleTab.dontSwitchIfFocus1="Wechsle nicht wenn"
+AdvSceneSwitcher.idleTab.dontSwitchIfFocus2="im Fokus ist"
+
+; Scene Sequence Tab
+AdvSceneSwitcher.sceneSequenceTab.title="Szenenfolge"
+AdvSceneSwitcher.sceneSequenceTab.description="Eine Szenenfolge kann durch Pausieren, Stoppen des Szenenwechslers oder manuelle Szenenwechsel abgebrochen werden"
+AdvSceneSwitcher.sceneSequenceTab.save="Speichere Szenenfolgen in eine Datei"
+AdvSceneSwitcher.sceneSequenceTab.load="Lade Szenenfolgen von einer Datei"
+AdvSceneSwitcher.sceneSequenceTab.saveTitle="Speichere Szenenfolgen in eine Datei ..."
+AdvSceneSwitcher.sceneSequenceTab.loadTitle="Wähle eine Datei aus von der Szenenfolgen gelesen werden sollen ..."
+AdvSceneSwitcher.sceneSequenceTab.loadFail="Laden der Einstellungen ist fehlgeschlagen!"
+AdvSceneSwitcher.sceneSequenceTab.loadSuccess="Laden der Einstellungen war erfolgreich!"
+AdvSceneSwitcher.sceneSequenceTab.fileType="Text Dateien (*.txt)"
+AdvSceneSwitcher.sceneSequenceTab.interruptible="kann unterbrochen werden"
+AdvSceneSwitcher.sceneSequenceTab.interruptibleHint="Andere Szenenwechselmethoden können diese Sequenz unterbrechen"
+AdvSceneSwitcher.sceneSequenceTab.entry="Wenn {{startScenes}} aktiv ist wechsle zu {{scenes}} nach {{delay}} {{delayUnits}} mit {{transitions}} {{interruptible}}"
+AdvSceneSwitcher.sceneSequenceTab.help="Dieser Tab ermöglicht es automatisiert zu einer anderen Szene zu wechseln, nachdem eine Szene für die konfigurierte Zeit aktiv war.\nZum Beispiel kann so automatisch zwischen zwei Szenen hin und her gewechselt werden.\n\nKlicke auf das markierte Plus Symbol, um einen neuen Eintrag hinzuzufügen."
+
+; Audio Tab
+AdvSceneSwitcher.audioTab.title="Audio"
+AdvSceneSwitcher.audioTab.condition.above="über"
+AdvSceneSwitcher.audioTab.condition.below="unter"
+AdvSceneSwitcher.audioTab.entry="Wenn die Lautstärke von {{audioSources}} {{condition}} {{volumeWidget}} ist für {{duration}} wechsle zu {{scenes}} mit {{transitions}}"
+AdvSceneSwitcher.audioTab.multiMatchfallbackCondition="Wenn mehrere Einträge zutreffen ..."
+AdvSceneSwitcher.audioTab.multiMatchfallback="... für {{duration}} wechsle zu {{scenes}} mit {{transitions}}"
+AdvSceneSwitcher.audioTab.help="Dieser Tab ermöglicht es basierend auf der Lautstärke von Audioquellen Szenen zu wechseln.\nSo kann zum Beispiel automatisch zu einer Szene gewechselt werden, wenn die Lautstärke eines Mikrofons eine konfigurierte Schwelle überschreitet.\n\nKlicke auf das markierte Plus Symbol, um einen neuen Eintrag hinzuzufügen."
+
+; Scene Group Tab
+AdvSceneSwitcher.sceneGroupTab.title="Szenengruppe"
+AdvSceneSwitcher.sceneGroupTab.list="Szenengruppen"
+AdvSceneSwitcher.sceneGroupTab.edit="Szenengruppe bearbeiten"
+AdvSceneSwitcher.sceneGroupTab.edit.name="Name:"
+AdvSceneSwitcher.sceneGroupTab.edit.type="Typ: {{type}}"
+AdvSceneSwitcher.sceneGroupTab.type.count="Anzahl"
+AdvSceneSwitcher.sceneGroupTab.type.time="Zeit"
+AdvSceneSwitcher.sceneGroupTab.type.random="Zufall"
+AdvSceneSwitcher.sceneGroupTab.edit.count="Schreite zur nächsten Szene in dieser Gruppe fort nach {{count}} Szenewechseln"
+AdvSceneSwitcher.sceneGroupTab.edit.time="Schreite zur nächsten Szene in dieser Gruppe fort nach {{time}}"
+AdvSceneSwitcher.sceneGroupTab.edit.random="Wähle eine zufällig Szene in der Liste aus"
+AdvSceneSwitcher.sceneGroupTab.edit.repeat="Beginne von vorne wenn Ende der Szenenliste erreicht ist"
+AdvSceneSwitcher.sceneGroupTab.edit.addScene="Szene hinzufügen"
+AdvSceneSwitcher.sceneGroupTab.add="Szenengruppe hinzufügen"
+AdvSceneSwitcher.sceneGroupTab.defaultname="Szenengruppe %1"
+AdvSceneSwitcher.sceneGroupTab.exists="Szenengruppen- oder Szenenname existiert bereits"
+AdvSceneSwitcher.sceneGroupTab.help="Szenengruppen können, genau wie reguläre Szenen, als Ziel eines Szenenwechsler Eintrags ausgewählt werden.\n\nSzenengruppen bestehen aus einer Liste von Szenen.\nDie aktive Szene der Szenengruppe schreitet abhängig von den konfigurierten Einstellungen durch die Liste der zugewiesenen Szenen fort.\n\nMögliche Einstellungen zum Fortschreiten der aktiven Szene sind:\nAnzahl der Szenenwechsel.\nZeit seit dem letzten Szenenwechsel in der Szenengruppe.\nOder zufällig.\n\nSo kann zum Beispiel eine Szenengruppe welche die folgenden Szenen enthält ...\nSzene 1\nSzene 2\nSzene 3 \n... beim erstem Mal zu \"Szene 1\" wechseln.\nBeim zweiten Mal zu \"Szene 2\".\nDie restlichem Male wechselt die Szenengruppe zu \"Szene 3\".\n\nKlicke auf das markierte Plus Symbol, um eine neuen Szenengruppe hinzuzufügen."
+AdvSceneSwitcher.sceneGroupTab.scenes.help="Wähle die Szenengruppe, die du bearbeiten möchtest, auf der linken Seite aus.\n\nWähle oben eine Szene aus, die du zur Szenengruppe hinzufügen möchtest, und klicke das Plus Symbol.\n\nDie gleiche Szene kann mehrfach in derselben Szenengruppe auftauchen."
+
+; Scene Trigger Tab
+AdvSceneSwitcher.sceneTriggerTab.title="Szenen Trigger"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerType.none="--Trigger auswählen--"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerType.sceneActive="aktiv ist"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerType.sceneInactive="nicht aktiv ist"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerType.sceneLeave="verlassen wird"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.none="--Aktion auswählen--"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.startRecording="Aufnahme starten"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.pauseRecording="Aufnahme pausieren"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.unpauseRecording="Aufnahme fortsetzen"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.stopRecording="Aufnahme stoppen"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.stopStreaming="Streamen stoppen"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.startStreaming="Streamen starten"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.startReplayBuffer="Replay Buffer starten"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.stopReplayBuffer="Replay Buffer stoppen"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.muteSource="Quelle stumm schalten"
+AdvSceneSwitcher.sceneTriggerTab.entry="Wenn {{scenes}} {{triggers}} {{actions}} {{audioSources}} nach {{duration}} "
+AdvSceneSwitcher.sceneTriggerTab.help="Dieser Tab ermöglicht es automatisiert Handlungen, wie etwa das Stoppen von einer Aufnahme oder des Streamens, bei einem Szenenwechsel auszuführen."
+
+
+; Hotkey
+AdvSceneSwitcher.hotkey.startSwitcherHotkey="Starte den Erweiteren Szenenwechsler"
+AdvSceneSwitcher.hotkey.stopSwitcherHotkey="Stoppe den Erweiteren Szenenwechsler"
+AdvSceneSwitcher.hotkey.startStopToggleSwitcherHotkey="Starte/Stoppe den Erweiteren Szenenwechsler"
+
+AdvSceneSwitcher.askBackup="Neue Version des Erweiterten Automatischen Szenenwechslers wurde erkannt.\nSoll ein Backup der alten Einstellungen angelegt werden?"
+
+AdvSceneSwitcher.close="Schließen"
+AdvSceneSwitcher.browse="Öffnen"
+
+AdvSceneSwitcher.selectScene="--Szene auswählen--"
+AdvSceneSwitcher.selectPreviousScene="Vorhergehende Szene"
+AdvSceneSwitcher.selectTransition="--Szenenübergang auswählen--"
+AdvSceneSwitcher.selectWindow="--Fenster auswählen--"
+AdvSceneSwitcher.selectAudioSource="--Audio Quelle auswählen--"
+AdvSceneSwitcher.selectMediaSource="--Medien Quelle auswählen--"
+AdvSceneSwitcher.selectProcess="--Prozess auswählen--"
+AdvSceneSwitcher.enterPath="--Pfad eingeben--"
+AdvSceneSwitcher.enterText="--Text eingeben--"
+AdvSceneSwitcher.invaildEntriesWillNotBeSaved="Ungültige Einträge werden nicht gespeichert"
+AdvSceneSwitcher.selectWindowTip="Benutze \"OBS\" um das OBS-Studio Fenster auszuwählen\nBenutze\"Task Switching\"um die ALT + TAB Tastenkombination auszuwählen"
+
+AdvSceneSwitcher.status.active="Aktiv"
+AdvSceneSwitcher.status.inactive="Inaktiv"
+
+AdvSceneSwitcher.unit.milliseconds="Millisekunden"
+AdvSceneSwitcher.unit.secends="Sekunden"
+AdvSceneSwitcher.unit.minutes="Minuten"
+AdvSceneSwitcher.unit.hours="Stunden"

data/locale/en-US.ini

@@ -0,0 +1,267 @@
+AdvSceneSwitcher.pluginName="Advanced Scene Switcher"
+AdvSceneSwitcher.windowTitle="Advanced Scene Switcher"
+
+; General Tab
+AdvSceneSwitcher.generalTab.title="General"
+AdvSceneSwitcher.generalTab.status="Status"
+AdvSceneSwitcher.generalTab.status.hotkeytips="Hotkeys can be defined in the OBS settings"
+AdvSceneSwitcher.generalTab.status.currentStatus="Advanced Scene Switcher is:"
+AdvSceneSwitcher.generalTab.status.onStartup="On startup of OBS:"
+AdvSceneSwitcher.generalTab.status.onStartup.asLastRun="Start the scene switcher if it was running"
+AdvSceneSwitcher.generalTab.status.onStartup.alwaysStart="Always start the scene switcher"
+AdvSceneSwitcher.generalTab.status.onStartup.doNotStart="Do not start the scene switcher"
+AdvSceneSwitcher.generalTab.status.start="Start"
+AdvSceneSwitcher.generalTab.status.stop="Stop"
+AdvSceneSwitcher.generalTab.status.autoStart="Automatically start the scene switcher when:"
+AdvSceneSwitcher.generalTab.status.autoStart.never="Never"
+AdvSceneSwitcher.generalTab.status.autoStart.recording="Recording"
+AdvSceneSwitcher.generalTab.status.autoStart.streaming="Streaming"
+AdvSceneSwitcher.generalTab.status.autoStart.recordingAndStreaming="Recording or Streaming"
+AdvSceneSwitcher.generalTab.status.checkInterval="Check switch conditions every"
+AdvSceneSwitcher.generalTab.generalBehavior="General behavior"
+AdvSceneSwitcher.generalTab.generalBehavior.onNoMet="If no switch condition is met for"
+AdvSceneSwitcher.generalTab.generalBehavior.onNoMetDelayTooltip="Will only ever be as accurate as the configured check interval."
+AdvSceneSwitcher.generalTab.generalBehavior.onNoMet.dontSwitch="Don't switch"
+AdvSceneSwitcher.generalTab.generalBehavior.onNoMet.switchToRandom="Switch to any scene in Random tab"
+AdvSceneSwitcher.generalTab.generalBehavior.onNoMet.switchTo="Switch to:"
+AdvSceneSwitcher.generalTab.generalBehavior.cooldown="After a match do not switch scenes for"
+AdvSceneSwitcher.generalTab.generalBehavior.cooldownHint="During this time potential matches will be ignored!"
+AdvSceneSwitcher.generalTab.generalBehavior.verboseLogging="Enable verbose logging"
+AdvSceneSwitcher.generalTab.generalBehavior.disableUIHints="Disable UI hints"
+AdvSceneSwitcher.generalTab.priority="Priority"
+AdvSceneSwitcher.generalTab.priority.description="Switching methods priority (Highest priority is at the top)"
+AdvSceneSwitcher.generalTab.priority.threadPriority="Use thread priority"
+AdvSceneSwitcher.generalTab.priority.threadPriorityNotice="(Raising the priority above \"Normal\" is not recommended)"
+AdvSceneSwitcher.generalTab.saveOrLoadsettings="Save / load settings"
+AdvSceneSwitcher.generalTab.saveOrLoadsettings.export="Export"
+AdvSceneSwitcher.generalTab.saveOrLoadsettings.import="Import"
+AdvSceneSwitcher.generalTab.saveOrLoadsettings.exportWindowTitle="Export Advanced Scene Switcher settings to file ..."
+AdvSceneSwitcher.generalTab.saveOrLoadsettings.importWindowTitle="Import Advanced Scene Switcher settings from file ..."
+AdvSceneSwitcher.generalTab.saveOrLoadsettings.textType="Text files (*.txt)"
+AdvSceneSwitcher.generalTab.saveOrLoadsettings.loadFail="Advanced Scene Switcher failed to import settings"
+AdvSceneSwitcher.generalTab.saveOrLoadsettings.loadSuccess="Advanced Scene Switcher settings imported successfully"
+AdvSceneSwitcher.generalTab.priority.fileContent="File Content"
+AdvSceneSwitcher.generalTab.priority.sceneSequence="Scene Sequence"
+AdvSceneSwitcher.generalTab.priority.idleDetection="Idle Detection"
+AdvSceneSwitcher.generalTab.priority.executable="Executable"
+AdvSceneSwitcher.generalTab.priority.screenRegion="Screen Region"
+AdvSceneSwitcher.generalTab.priority.windowTitle="Window Title"
+AdvSceneSwitcher.generalTab.priority.media="Media"
+AdvSceneSwitcher.generalTab.priority.time="Time"
+AdvSceneSwitcher.generalTab.priority.audio="Audio"
+
+; Transition Tab
+AdvSceneSwitcher.transitionTab.title="Transition"
+AdvSceneSwitcher.transitionTab.transitionOverride="Scene transitions defined in the scene switcher take priority over Transition Overrides defined per scene"
+AdvSceneSwitcher.transitionTab.transitionForAToB="Use transition for automated scene switch from scene A to scene B"
+AdvSceneSwitcher.transitionTab.transitionsHelp="<html><head/><body><p>These settings <span style=\"font-style:italic;\">only</span> affect transitions caused by the scene switcher - Check out <a href=\"https://obsproject.com/forum/resources/transition-table.1174/\"><span style=\" text-decoration: underline; color:#268bd2;\">Transition Table</span></a> if you want to configure this for manual scene changes.<br/>Settings defined here take priority over transition settings configured elsewhere in the scene switcher.<br/><br/>Click the plus symbol below to add a new entry.</p></body></html>"
+AdvSceneSwitcher.transitionTab.defaultTransition="Change transition if scene is active"
+AdvSceneSwitcher.transitionTab.entry="Switch from {{scenes}} to {{scenes2}} using {{transitions}}"
+AdvSceneSwitcher.transitionTab.defaultTransitionEntry="When scene {{scenes}} is active change default scene transition to {{transitions}}"
+AdvSceneSwitcher.transitionTab.defaultTransitionsHelp="Click on the plus symbol to add an entry."
+
+; Pause Scenes Tab
+AdvSceneSwitcher.pauseTab.title="Pause"
+AdvSceneSwitcher.pauseTab.pauseOnScene="Pause the Scene Switcher on scene"
+AdvSceneSwitcher.pauseTab.pauseInFocus1="Pause the Scene Switcher when "
+AdvSceneSwitcher.pauseTab.pauseInFocus2="is in focus"
+AdvSceneSwitcher.pauseTab.pauseTypeScene="scene is active"
+AdvSceneSwitcher.pauseTab.pauseTypeWindow="window is in focus"
+AdvSceneSwitcher.pauseTab.pauseTargetAll="all"
+AdvSceneSwitcher.pauseTab.pauseEntry="Pause {{pauseTargets}} checks when {{pauseTypes}} {{scenes}} {{windows}}"
+AdvSceneSwitcher.pauseTab.help="On this tab you can configure to pause individual switching methods if a scene is active or window is in focus.\n\nClick on the highlighted plus symbol to continue."
+
+; Window Title Tab
+AdvSceneSwitcher.windowTitleTab.title="Title"
+AdvSceneSwitcher.windowTitleTab.regexrDescription="<html><head/><body><p>Enter either direct window titles or valid regex. You can check syntax and matches for regular expressions using <a href=\"https://regexr.com\"><span style=\" text-decoration: underline; color:#268bd2;\">RegExr</span></a></p></body></html>"
+AdvSceneSwitcher.windowTitleTab.stayInFocus1="Ignore this window name"
+AdvSceneSwitcher.windowTitleTab.stayInFocus2=" "
+AdvSceneSwitcher.windowTitleTab.fullscreen="if fullscreen"
+AdvSceneSwitcher.windowTitleTab.maximized="if maximized"
+AdvSceneSwitcher.windowTitleTab.focused="if focused"
+AdvSceneSwitcher.windowTitleTab.entry="{{windows}} {{scenes}} {{transitions}} {{fullscreen}} {{maximized}} {{focused}}"
+AdvSceneSwitcher.windowTitleTab.windowsHelp="Switch scenes based on the window title of running applications.\nThe following additional conditions can be selected:\nThe window is Fullscreen\nThe window is maximized\nThe window is focused\n\nClick on the highlighted plus symbol to continue."
+AdvSceneSwitcher.windowTitleTab.ignoreWindowsHelp="If a window title is ignored the scene switcher will act as if the previously selected window is still in focus.\nThis will allow you to avoid scene switches, if you frequently switch to a different window, which shall not trigger a scene change.\n\nChoose a window or enter a window title above and click on the plus symbol below to add it to the list."
+
+; Executable Tab
+AdvSceneSwitcher.executableTab.title="Executable"
+AdvSceneSwitcher.executableTab.implemented="Implemented by dasOven"
+AdvSceneSwitcher.executableTab.requiresFocus="only if focused"
+AdvSceneSwitcher.executableTab.entry="When {{processes}} is running switch to {{scenes}} using {{transitions}} {{requiresFocus}}"
+AdvSceneSwitcher.executableTab.help="This tab will allow you to automatically switch scenes if a process is running.\nThis can be useful in situations where the window name could change or is not known.\n\nClick on the highlighted plus symbol to continue."
+
+; Screen Region Tab
+AdvSceneSwitcher.screenRegionTab.title="Region"
+AdvSceneSwitcher.screenRegionTab.currentPosition="Cursor is currently at:"
+AdvSceneSwitcher.screenRegionTab.showGuideFrames="Show guide frames"
+AdvSceneSwitcher.screenRegionTab.hideGuideFrames="Hide guide frames"
+AdvSceneSwitcher.screenRegionTab.excludeScenes.None="No selection"
+AdvSceneSwitcher.screenRegionTab.entry="If cursor is in {{minX}} {{minY}} x {{maxX}} {{maxY}} switch to {{scenes}} using {{transitions}} unless in {{excludeScenes}}"
+AdvSceneSwitcher.screenRegionTab.help="This tab will allow you to automatically switch scenes based on the current position of your mouse cursor.\n\nClick on the highlighted plus symbol to continue."
+
+; Media Tab
+AdvSceneSwitcher.mediaTab.title="Media"
+AdvSceneSwitcher.mediaTab.implemented="Implemented by Exeldro"
+AdvSceneSwitcher.mediaTab.states.none="None"
+AdvSceneSwitcher.mediaTab.states.playing="Playing"
+AdvSceneSwitcher.mediaTab.states.opening="Opening"
+AdvSceneSwitcher.mediaTab.states.buffering="Buffering"
+AdvSceneSwitcher.mediaTab.states.Paused="Paused"
+AdvSceneSwitcher.mediaTab.states.stopped="Stopped"
+AdvSceneSwitcher.mediaTab.states.ended="Ended"
+AdvSceneSwitcher.mediaTab.states.error="Error"
+AdvSceneSwitcher.mediaTab.states.playedToEnd="Played to end"
+AdvSceneSwitcher.mediaTab.states.any="Any"
+AdvSceneSwitcher.mediaTab.timeRestriction.none="None"
+AdvSceneSwitcher.mediaTab.timeRestriction.shorter="Time shorter"
+AdvSceneSwitcher.mediaTab.timeRestriction.longer="Time longer"
+AdvSceneSwitcher.mediaTab.timeRestriction.remainShorter="Time remaining shorter"
+AdvSceneSwitcher.mediaTab.timeRestriction.remainLonger="Time remaining longer"
+AdvSceneSwitcher.mediaTab.entry="When {{mediaSources}} state is {{states}} and {{timeRestrictions}} {{time}} switch to {{scenes}} using {{transitions}}"
+AdvSceneSwitcher.mediaTab.help="This tab will allow you to switch scenes based on the states of media sources.\nFor example, you can automatically switch back to the previous scene once the selected media sourced ended its playback.\n\nClick on the highlighted plus symbol to continue."
+
+; File Tab
+AdvSceneSwitcher.fileTab.title="File"
+AdvSceneSwitcher.fileTab.readWriteSceneFile="Read / write scene from / to file"
+AdvSceneSwitcher.fileTab.currentSceneOutputFile="Write the name of the current scene to this file:"
+AdvSceneSwitcher.fileTab.switchSceneBaseOnFile="Enable switching of scenes based on file input"
+AdvSceneSwitcher.fileTab.switchSceneNameInputFile="Read scene name to be switched to from this file:"
+AdvSceneSwitcher.fileTab.switchSceneBaseOnFileContent="Switch scene based on file contents"
+AdvSceneSwitcher.fileTab.remoteFileWarning="Please note that if you choose the remote option the scene switcher will try to access the remote location every x ms as specified on the General tab!"
+AdvSceneSwitcher.fileTab.remoteFileWarning1="Note that the scene switcher will try to access the remote location every "
+AdvSceneSwitcher.fileTab.remoteFileWarning2="ms"
+AdvSceneSwitcher.fileTab.libcurlWarning="Failed to load libcurl! Accessing remote files will not be possible!"
+AdvSceneSwitcher.fileTab.selectWrite="Select a file to write to ..."
+AdvSceneSwitcher.fileTab.selectRead="Select a file to read from ..."
+AdvSceneSwitcher.fileTab.textFileType="Text files (*.txt)"
+AdvSceneSwitcher.fileTab.anyFileType="Any files (*.*)"
+AdvSceneSwitcher.fileTab.remote="remote file"
+AdvSceneSwitcher.fileTab.local="local file"
+AdvSceneSwitcher.fileTab.useRegExp="use regular expressions (pattern matching)"
+AdvSceneSwitcher.fileTab.checkfileContentTime="if modification date changed"
+AdvSceneSwitcher.fileTab.checkfileContent="if content changed"
+AdvSceneSwitcher.fileTab.entry="Switch to {{scenes}} using {{transitions}} if content of {{fileType}} {{filePath}} {{browseButton}} matches:"
+AdvSceneSwitcher.fileTab.entry2="{{matchText}}"
+AdvSceneSwitcher.fileTab.entry3="{{useRegex}} {{checkModificationDate}} {{checkFileContent}}"
+AdvSceneSwitcher.fileTab.help="This tab will allow you to automatically switch scenes based on the content of remote or local files.\n\nClick on the highlighted plus symbol to continue."
+
+; Random Tab
+AdvSceneSwitcher.randomTab.title="Random"
+AdvSceneSwitcher.randomTab.randomDisabledWarning="Functionality disabled - To activate select \"If no switch condition is met switch to any scene in Random tab\" on General tab"
+AdvSceneSwitcher.randomTab.entry="If no switch condition is met switch to {{scenes}} using {{transitions}} for {{delay}}"
+AdvSceneSwitcher.randomTab.help="The scene switcher will randomly choose an entry on this tab to switch to for the configured time.\nNote that the same entry will not be chosen twice in a row.\n\nClick on the highlighted plus symbol to continue."
+
+; Time Tab
+AdvSceneSwitcher.timeTab.title="Time"
+AdvSceneSwitcher.timeTab.anyDay="On any day"
+AdvSceneSwitcher.timeTab.mondays="Mondays"
+AdvSceneSwitcher.timeTab.tuesdays="Tuesdays"
+AdvSceneSwitcher.timeTab.wednesdays="Wednesdays"
+AdvSceneSwitcher.timeTab.thursdays="Thursdays"
+AdvSceneSwitcher.timeTab.fridays="Fridays"
+AdvSceneSwitcher.timeTab.saturdays="Saturdays"
+AdvSceneSwitcher.timeTab.sundays="Sundays"
+AdvSceneSwitcher.timeTab.afterstart="After streaming/recording start"
+AdvSceneSwitcher.timeTab.afterstart.tip="The time relative to the start of streaming / recording will be used"
+AdvSceneSwitcher.timeTab.entry="{{triggers}} at {{time}} switch to {{scenes}} using {{transitions}}"
+AdvSceneSwitcher.timeTab.help="This tab will allow you to automatically switch to a different scene based on the current local time.\n\nNote that the scene switcher will only switch scenes at the exact time you specified.\nMake sure you have configured the priority settings on the General tab to your liking so the selected time point will not be missed due to other switching methods having a higher priority.\n\nClick on the highlighted plus symbol to continue."
+
+; Idle Tab
+AdvSceneSwitcher.idleTab.title="Idle"
+AdvSceneSwitcher.idleTab.enable="Enable Idle Detection"
+AdvSceneSwitcher.idleTab.idleswitch="After {{duration}} of no keyboard or mouse inputs switch to scene {{scenes}} using the {{transitions}}"
+AdvSceneSwitcher.idleTab.dontSwitchIfFocus1="Do not switch if"
+AdvSceneSwitcher.idleTab.dontSwitchIfFocus2="is in focus"
+
+; Scene Sequence Tab
+AdvSceneSwitcher.sceneSequenceTab.title="Sequence"
+AdvSceneSwitcher.sceneSequenceTab.description="A sequence of automatic scene switches can be cancelled by either pausing/stopping the scene switcher or manually switching to a different scene"
+AdvSceneSwitcher.sceneSequenceTab.save="Save scene sequences to file"
+AdvSceneSwitcher.sceneSequenceTab.load="Load scene sequences from file"
+AdvSceneSwitcher.sceneSequenceTab.saveTitle="Save Scene Sequence to file ..."
+AdvSceneSwitcher.sceneSequenceTab.loadTitle="Select a file to read Scene Sequence from ..."
+AdvSceneSwitcher.sceneSequenceTab.loadFail="Advanced Scene Switcher failed to import settings!"
+AdvSceneSwitcher.sceneSequenceTab.loadSuccess="Advanced Scene Switcher settings imported successfully!"
+AdvSceneSwitcher.sceneSequenceTab.fileType="Text files (*.txt)"
+AdvSceneSwitcher.sceneSequenceTab.interruptible="interruptible"
+AdvSceneSwitcher.sceneSequenceTab.interruptibleHint="Other switching methods are allowed to interrupt this scene sequence"
+AdvSceneSwitcher.sceneSequenceTab.entry="When {{startScenes}} is active switch to {{scenes}} after {{delay}} {{delayUnits}} using {{transitions}} {{interruptible}}"
+AdvSceneSwitcher.sceneSequenceTab.help="This tab will allow you to automatically switch to a different scene if a scene was active for a configured period of time.\nFor example, you could automatically cycle back and forth between two scenes automatically.\n\nClick on the highlighted plus symbol to continue."
+
+; Audio Tab
+AdvSceneSwitcher.audioTab.title="Audio"
+AdvSceneSwitcher.audioTab.condition.above="above"
+AdvSceneSwitcher.audioTab.condition.below="below"
+AdvSceneSwitcher.audioTab.entry="When the volume of {{audioSources}} is {{condition}} {{volumeWidget}} for {{duration}} switch to {{scenes}} using {{transitions}}"
+AdvSceneSwitcher.audioTab.multiMatchfallbackCondition="If multiple entries match ..."
+AdvSceneSwitcher.audioTab.multiMatchfallback="... for {{duration}} switch to {{scenes}} using {{transitions}}"
+AdvSceneSwitcher.audioTab.help="This tab will allow you to switch scenes based on the volume of sources.\nFor example, you could automatically switch to a different scene if the volume of your microphone reaches a certain threshold.\n\nClick on the highlighted plus symbol to continue."
+
+; Scene Group Tab
+AdvSceneSwitcher.sceneGroupTab.title="Scene Group"
+AdvSceneSwitcher.sceneGroupTab.list="Scene Groups"
+AdvSceneSwitcher.sceneGroupTab.edit="Edit Scene Groups"
+AdvSceneSwitcher.sceneGroupTab.edit.name="Name:"
+AdvSceneSwitcher.sceneGroupTab.edit.type="Type: {{type}}"
+AdvSceneSwitcher.sceneGroupTab.type.count="Count"
+AdvSceneSwitcher.sceneGroupTab.type.time="Time"
+AdvSceneSwitcher.sceneGroupTab.type.random="Random"
+AdvSceneSwitcher.sceneGroupTab.edit.count="Advance to next scene in list after {{count}} matches"
+AdvSceneSwitcher.sceneGroupTab.edit.time="Advance to next scene in list after {{time}} has passed"
+AdvSceneSwitcher.sceneGroupTab.edit.random="Choose next scene in list at random"
+AdvSceneSwitcher.sceneGroupTab.edit.repeat="Start from beginning if end of scene list is reached"
+AdvSceneSwitcher.sceneGroupTab.edit.addScene="Add scene"
+AdvSceneSwitcher.sceneGroupTab.add="Add Scene Group"
+AdvSceneSwitcher.sceneGroupTab.defaultname="Scene Group %1"
+AdvSceneSwitcher.sceneGroupTab.exists="Scene Group or Scene name exists already"
+AdvSceneSwitcher.sceneGroupTab.help="Scene Groups can be selected as a target just like a regular scene.\n\nAs the name suggests a scene group is a collection of multiple scenes.\nThe scene group will advance through the list of its assigned scenes depending on the configured settings, which can be found on the right side.\n\nYou can configure the scene group to advance to the next scene in the list:\nAfter a number of times the scene group is selected as a target.\nAfter a certain amount of time has passed.\nOr randomly.\n\nFor example, a scene group containing the scenes ...\nScene 1\nScene 2\nScene 3 \n... will activate \"Scene 1\" the first time it is selected as a target.\nThe second time it will activate \"Scene 2\".\nThe remaining times \"Scene 3\" will be activated.\n\nClick the highlighted plus symbol below to add a new scene group."
+AdvSceneSwitcher.sceneGroupTab.scenes.help="Select the scene group you want to modify on the left.\n\nSelect a scene to add to this scene group by selecting the scene above and clicking the plus symbol below.\n\nA scene can be added multiple times to the same scene group."
+
+; Scene Trigger Tab
+AdvSceneSwitcher.sceneTriggerTab.title="Scene Triggers"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerType.none="--select trigger--"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerType.sceneActive="is active"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerType.sceneInactive="is not active"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerType.sceneLeave="switched away from"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.none="--select action--"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.startRecording="start recording"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.pauseRecording="pause recording"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.unpauseRecording="unpause recording"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.stopRecording="stop recording"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.stopStreaming="stop streaming"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.startStreaming="start streaming"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.startReplayBuffer="start replay buffer"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.stopReplayBuffer="stop replay buffer"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.muteSource="mute source"
+AdvSceneSwitcher.sceneTriggerTab.entry="When {{scenes}} {{triggers}} {{actions}} {{audioSources}} after {{duration}}"
+AdvSceneSwitcher.sceneTriggerTab.help="This tab allows you to trigger actions on scene changes, like stopping recording or streaming."
+
+; Hotkey
+AdvSceneSwitcher.hotkey.startSwitcherHotkey="Start the Advanced Scene Switcher"
+AdvSceneSwitcher.hotkey.stopSwitcherHotkey="Stop the Advanced Scene Switcher"
+AdvSceneSwitcher.hotkey.startStopToggleSwitcherHotkey="Toggle Start/Stop for the Advanced Scene Switcher"
+
+AdvSceneSwitcher.askBackup="Detected a new version of the Advanced Scene Switcher.\nShould a backup of the old settings be created?"
+
+AdvSceneSwitcher.close="Close"
+AdvSceneSwitcher.browse="Browse"
+
+AdvSceneSwitcher.selectScene="--select scene--"
+AdvSceneSwitcher.selectPreviousScene="Previous Scene"
+AdvSceneSwitcher.selectTransition="--select transition--"
+AdvSceneSwitcher.selectWindow="--select window--"
+AdvSceneSwitcher.selectAudioSource="--select audio source--"
+AdvSceneSwitcher.selectMediaSource="--select media source--"
+AdvSceneSwitcher.selectProcess="--select process--"
+AdvSceneSwitcher.enterPath="--enter path--"
+AdvSceneSwitcher.enterText="--enter text--"
+AdvSceneSwitcher.invaildEntriesWillNotBeSaved="invalid entries will not be saved"
+AdvSceneSwitcher.selectWindowTip="Use \"OBS\" to specify OBS window\nUse \"Task Switching\"to specify ALT + TAB"
+
+AdvSceneSwitcher.status.active="Active"
+AdvSceneSwitcher.status.inactive="Inactive"
+
+AdvSceneSwitcher.unit.milliseconds="milliseconds"
+AdvSceneSwitcher.unit.secends="seconds"
+AdvSceneSwitcher.unit.minutes="minutes"
+AdvSceneSwitcher.unit.hours="hours"

data/locale/zh-CN.ini

@@ -0,0 +1,203 @@
+AdvSceneSwitcher.pluginName="高级场景切换器"
+AdvSceneSwitcher.windowTitle="高级场景切换器"
+
+; General Tab
+AdvSceneSwitcher.generalTab.title="通用"
+AdvSceneSwitcher.generalTab.status="状态"
+AdvSceneSwitcher.generalTab.status.hotkeytips="快捷键可在OBS设置中设置"
+AdvSceneSwitcher.generalTab.status.currentStatus="当前状态："
+AdvSceneSwitcher.generalTab.status.onStartup="在OBS启动时"
+AdvSceneSwitcher.generalTab.status.onStartup.asLastRun="按照最后运行时的状态"
+AdvSceneSwitcher.generalTab.status.onStartup.alwaysStart="总是自动启动"
+AdvSceneSwitcher.generalTab.status.onStartup.doNotStart="不要启动"
+AdvSceneSwitcher.generalTab.status.start="启动"
+AdvSceneSwitcher.generalTab.status.stop="停止"
+AdvSceneSwitcher.generalTab.status.autoStart.recording="录制"
+AdvSceneSwitcher.generalTab.status.autoStart.streaming="推流"
+AdvSceneSwitcher.generalTab.status.autoStart.recordingAndStreaming="录制和推流"
+AdvSceneSwitcher.generalTab.status.checkInterval="检查切换条件时间间隔"
+AdvSceneSwitcher.generalTab.generalBehavior="一般表现"
+AdvSceneSwitcher.generalTab.generalBehavior.onNoMet="如果不符合任何切换条件"
+AdvSceneSwitcher.generalTab.generalBehavior.onNoMetDelayTooltip="时间精度最高只能达到配置的轮询间隔"
+AdvSceneSwitcher.generalTab.generalBehavior.onNoMet.dontSwitch="不切换"
+AdvSceneSwitcher.generalTab.generalBehavior.onNoMet.switchToRandom="切换到随机场景列表中任意随机场景"
+AdvSceneSwitcher.generalTab.generalBehavior.onNoMet.switchTo="切换到"
+AdvSceneSwitcher.generalTab.generalBehavior.verboseLogging="详细日志输出"
+AdvSceneSwitcher.generalTab.generalBehavior.disableUIHints="禁用UI提示"
+AdvSceneSwitcher.generalTab.priority="优先级"
+AdvSceneSwitcher.generalTab.priority.description="切换场景优先级 (最上方的项优先级最高)"
+AdvSceneSwitcher.generalTab.priority.threadPriority="使用线程优先级"
+AdvSceneSwitcher.generalTab.priority.threadPriorityNotice="(不推荐使用高于 \"Normal\" 的优先级)"
+AdvSceneSwitcher.generalTab.saveOrLoadsettings="导出或导入设置"
+AdvSceneSwitcher.generalTab.saveOrLoadsettings.export="导出设置"
+AdvSceneSwitcher.generalTab.saveOrLoadsettings.import="导入设置"
+AdvSceneSwitcher.generalTab.saveOrLoadsettings.exportWindowTitle="导出高级场景切换器到文件..."
+AdvSceneSwitcher.generalTab.saveOrLoadsettings.importWindowTitle="导入高级场景切换器到文件..."
+AdvSceneSwitcher.generalTab.saveOrLoadsettings.textType="文本文件 (*.txt)"
+AdvSceneSwitcher.generalTab.saveOrLoadsettings.loadFail="高级场景切换器导入设置失败"
+AdvSceneSwitcher.generalTab.saveOrLoadsettings.loadSuccess="高级场景切换器导入设置成功"
+AdvSceneSwitcher.generalTab.priority.fileContent="文件内容"
+AdvSceneSwitcher.generalTab.priority.sceneSequence="场景序列"
+AdvSceneSwitcher.generalTab.priority.idleDetection="闲置检测"
+AdvSceneSwitcher.generalTab.priority.executable="程序"
+AdvSceneSwitcher.generalTab.priority.screenRegion="屏幕区域"
+AdvSceneSwitcher.generalTab.priority.windowTitle="窗口标题"
+AdvSceneSwitcher.generalTab.priority.media="媒体"
+AdvSceneSwitcher.generalTab.priority.time="时间"
+AdvSceneSwitcher.generalTab.priority.audio="音频"
+
+; Transition Tab
+AdvSceneSwitcher.transitionTab.title="转场特效"
+AdvSceneSwitcher.transitionTab.transitionOverride="在场景切换器中设定的转场特效优先级高于场景设定的转场特效"
+AdvSceneSwitcher.transitionTab.transitionForAToB="当自动从场景A切换到场景B时使用的转场特效"
+AdvSceneSwitcher.transitionTab.transitionsHelp="<html><head/><body><p>这里的设定<span style=\"font-style:bold;\">只影响由场景切换器引起的转场有效</span>，不影响你手动的引起的转场。<br/>在这里设定的转场特效优先级高于场景切换器其他地方设置的<br/><br/>Click the plus symbol below to continue.</p></body></html>"
+AdvSceneSwitcher.transitionTab.defaultTransition="当切换到这个场景时修改默认转场特效"
+AdvSceneSwitcher.transitionTab.switchDefaultLabel="活跃时切换默认转场特效为"
+AdvSceneSwitcher.transitionTab.entry="从场景 {{scenes}} 切换到场景 {{scenes2}} 时使用转场特效 {{transitions}}"
+AdvSceneSwitcher.transitionTab.defaultTransitionEntry="当场景 {{scenes}} 被激活时更改默认转场特效为 {{transitions}}"
+
+; Pause Scenes Tab
+AdvSceneSwitcher.pauseTab.title="暂停"
+AdvSceneSwitcher.pauseTab.pauseOnScene="当切换到这个场景时暂停场景切换器"
+AdvSceneSwitcher.pauseTab.pauseInFocus1="当窗口"
+AdvSceneSwitcher.pauseTab.pauseInFocus2="获得焦点时暂停场景切换器"
+
+; Window Title Tab
+AdvSceneSwitcher.windowTitleTab.title="窗口标题"
+AdvSceneSwitcher.windowTitleTab.regexrDescription="<html><head/><body><p>你可以直接输入窗口标题或正则表达式. 你可以使用<a href=\"https://regexr.com\"><span style=\" text-decoration: underline; color:#268bd2;\">RegExr</span></a>来检查验证你的正则表达式</p></body></html>"
+AdvSceneSwitcher.windowTitleTab.stayInFocus1="当前焦点窗口标题为"
+AdvSceneSwitcher.windowTitleTab.stayInFocus2="时保持当前场景"
+AdvSceneSwitcher.windowTitleTab.fullscreen="全屏时"
+AdvSceneSwitcher.windowTitleTab.maximized="最大化时"
+AdvSceneSwitcher.windowTitleTab.focused="窗口聚集时"
+AdvSceneSwitcher.windowTitleTab.entry="{{windows}} {{scenes}} {{transitions}} {{fullscreen}} {{maximized}} {{focused}}"
+
+; Executable Tab
+AdvSceneSwitcher.executableTab.title="程序"
+AdvSceneSwitcher.executableTab.implemented="感谢dasOven的实现"
+AdvSceneSwitcher.executableTab.requiresFocus="仅获得焦点时"
+AdvSceneSwitcher.executableTab.entry="当 {{processes}} 正在运行时使用 {{transitions}} 切换到 {{scenes}} {{requiresFocus}}"
+
+; Screen Region Tab
+AdvSceneSwitcher.screenRegionTab.title="屏幕区域"
+AdvSceneSwitcher.screenRegionTab.currentPosition="鼠标当前位置："
+AdvSceneSwitcher.screenRegionTab.showGuideFrames="显示区域边界"
+AdvSceneSwitcher.screenRegionTab.hideGuideFrames="隐藏区域边界"
+AdvSceneSwitcher.screenRegionTab.entry="如果鼠标在 {{minX}} {{minY}} x {{maxX}} {{maxY}} 使用转场特效 {{transitions}} 切换到场景 {{scenes}} unless in {{excludeScenes}}"
+
+; Media Tab
+AdvSceneSwitcher.mediaTab.title="媒体"
+AdvSceneSwitcher.mediaTab.implemented="感谢Exeldro的实现"
+AdvSceneSwitcher.mediaTab.states.none="空"
+AdvSceneSwitcher.mediaTab.states.playing="播放中"
+AdvSceneSwitcher.mediaTab.states.opening="正在打开"
+AdvSceneSwitcher.mediaTab.states.buffering="缓冲中"
+AdvSceneSwitcher.mediaTab.states.Paused="暂停"
+AdvSceneSwitcher.mediaTab.states.stopped="停止"
+AdvSceneSwitcher.mediaTab.states.ended="结束"
+AdvSceneSwitcher.mediaTab.states.error="错误"
+AdvSceneSwitcher.mediaTab.states.any="任意"
+AdvSceneSwitcher.mediaTab.timeRestriction.none="无"
+AdvSceneSwitcher.mediaTab.timeRestriction.shorter="播放时间小于"
+AdvSceneSwitcher.mediaTab.timeRestriction.longer="播放时间大于"
+AdvSceneSwitcher.mediaTab.timeRestriction.remainShorter="剩余时间少于"
+AdvSceneSwitcher.mediaTab.timeRestriction.remainLonger="剩余时间多于"
+AdvSceneSwitcher.mediaTab.entry="当 {{mediaSources}} 状态为 {{states}} 并且 {{timeRestrictions}} {{time}} 时使用转场特效 {{transitions}} 切换到场景 {{scenes}}"
+
+; File Tab
+AdvSceneSwitcher.fileTab.title="文件"
+AdvSceneSwitcher.fileTab.readWriteSceneFile="从文件加载或保存当前场景名"
+AdvSceneSwitcher.fileTab.currentSceneOutputFile="将当前场景写入到这个文件："
+AdvSceneSwitcher.fileTab.switchSceneBaseOnFile="启用从文件读取应切换到的场景名"
+AdvSceneSwitcher.fileTab.switchSceneNameInputFile="从这个文件读取应切换到的场景名:"
+AdvSceneSwitcher.fileTab.switchSceneBaseOnFileContent="根据文件内容切换场景"
+AdvSceneSwitcher.fileTab.remoteFileWarning="请注意 如果你使用网络文件，场景切换器会按照你在通用页设置的间隔时间尝试访问网络文件!"
+AdvSceneSwitcher.fileTab.remoteFileWarning1="注意，场景切换器会每 "
+AdvSceneSwitcher.fileTab.remoteFileWarning2="毫秒尝试访问网络文件"
+AdvSceneSwitcher.fileTab.libcurlWarning="无法加载 libcurl 库! 访问网络文件功能将不可用!"
+AdvSceneSwitcher.fileTab.selectWrite="写入到文件..."
+AdvSceneSwitcher.fileTab.selectRead="从文件读取..."
+AdvSceneSwitcher.fileTab.textFileType="文本文件 (*.txt)"
+AdvSceneSwitcher.fileTab.anyFileType="任意文件 (*.*)"
+AdvSceneSwitcher.fileTab.remote="网络"
+AdvSceneSwitcher.fileTab.local="本地"
+AdvSceneSwitcher.fileTab.useRegExp="使用正则表达式（模式匹配）"
+AdvSceneSwitcher.fileTab.checkfileContentTime="仅当文件修改时间改变时检查文件内容"
+AdvSceneSwitcher.fileTab.checkfileContent="仅当文件发生修改时"
+AdvSceneSwitcher.fileTab.entry="如果 {{fileType}} 文件 {{filePath}} {{browseButton}} 匹配下列规则，使用转场特效 {{transitions}} 切换到场景 {{scenes}}"
+AdvSceneSwitcher.fileTab.entry2="{{matchText}}"
+AdvSceneSwitcher.fileTab.entry3="{{useRegex}} {{checkModificationDate}} {{checkFileContent}}"
+
+; Random Tab
+AdvSceneSwitcher.randomTab.title="随机场景列表"
+AdvSceneSwitcher.randomTab.randomDisabledWarning="功能已被禁用 - 可通过在通用页设置\"如果不符合任何切换条件切换到随机场景列表中任意随机场景\"启用"
+AdvSceneSwitcher.randomTab.entry="如果没有切换器条件满足，使用转场特效 {{transitions}} 切换到场景 {{scenes}} 并停留 {{delay}}"
+
+; Time Tab
+AdvSceneSwitcher.timeTab.title="时间"
+AdvSceneSwitcher.timeTab.anyDay="每天"
+AdvSceneSwitcher.timeTab.mondays="每周一"
+AdvSceneSwitcher.timeTab.tuesdays="每周二"
+AdvSceneSwitcher.timeTab.wednesdays="每周三"
+AdvSceneSwitcher.timeTab.thursdays="每周四"
+AdvSceneSwitcher.timeTab.fridays="每周五"
+AdvSceneSwitcher.timeTab.saturdays="每周六"
+AdvSceneSwitcher.timeTab.sundays="每周日"
+AdvSceneSwitcher.timeTab.afterstart="推流或录制开始后"
+AdvSceneSwitcher.timeTab.afterstart.tip="相对于直播或录制开始之后的时间点"
+AdvSceneSwitcher.timeTab.entry="{{triggers}} 的 {{time}} 使用转场特效 {{transitions}} 切换到场景 {{scenes}}"
+
+; Idle Tab
+AdvSceneSwitcher.idleTab.title="闲置检测"
+AdvSceneSwitcher.idleTab.enable="启用闲置检测"
+AdvSceneSwitcher.idleTab.condition1="超过"
+AdvSceneSwitcher.idleTab.condition2="没有鼠标或键盘操作"
+AdvSceneSwitcher.idleTab.switchToScene="切换到场景"
+AdvSceneSwitcher.idleTab.usingTransition1="使用"
+AdvSceneSwitcher.idleTab.usingTransition2="转场特效"
+AdvSceneSwitcher.idleTab.dontSwitchIfFocus1="如果当前窗口焦点在"
+AdvSceneSwitcher.idleTab.dontSwitchIfFocus2="时不切换"
+
+; Scene Sequence Tab
+AdvSceneSwitcher.sceneSequenceTab.title="场景序列"
+AdvSceneSwitcher.sceneSequenceTab.description="自动场景序列可以通过暂停或停止场景切换器或者手动切换到其他场景来取消"
+AdvSceneSwitcher.sceneSequenceTab.save="保存当前序列到文件"
+AdvSceneSwitcher.sceneSequenceTab.load="从文件加载序列"
+AdvSceneSwitcher.sceneSequenceTab.saveTitle="保存当前序列到文件 ..."
+AdvSceneSwitcher.sceneSequenceTab.loadTitle="从文件加载序列 ..."
+AdvSceneSwitcher.sceneSequenceTab.loadFail="导入失败"
+AdvSceneSwitcher.sceneSequenceTab.loadSuccess="导入失败成功"
+AdvSceneSwitcher.sceneSequenceTab.fileType="文本文件 (*.txt)"
+AdvSceneSwitcher.sceneSequenceTab.entry="当场景 {{startScenes}} 被激活 {{delay}} {{delayUnits}}后使用转场特效 {{transitions}} 切换到场景 {{scenes}} {{interruptible}}"
+
+; Audio Tab
+AdvSceneSwitcher.audioTab.title="音频"
+AdvSceneSwitcher.audioTab.entry="当{{audioSources}} is {{condition}} {{volumeWidget}} for {{duration}} 使用转场特效 {{transitions}} 切换到场景 {{scenes}}"
+
+; Hotkey
+AdvSceneSwitcher.hotkey.startSwitcherHotkey="启动高级场景切换器"
+AdvSceneSwitcher.hotkey.stopSwitcherHotkey="停止高级场景切换器"
+AdvSceneSwitcher.hotkey.startStopToggleSwitcherHotkey="切换(启动/停止)高级场景切换器"
+
+AdvSceneSwitcher.close="关闭"
+AdvSceneSwitcher.browse="浏览文件"
+
+AdvSceneSwitcher.selectScene="--选择场景--"
+AdvSceneSwitcher.selectTransition="--选择转场特效--"
+AdvSceneSwitcher.selectWindow="--选择窗口--"
+AdvSceneSwitcher.selectAudioSource="--选择音频源--"
+AdvSceneSwitcher.selectMediaSource="--选择媒体源--"
+AdvSceneSwitcher.selectProcess="--选择进程--"
+AdvSceneSwitcher.enterPath="--输入路径--"
+AdvSceneSwitcher.enterText="--输入文本--"
+AdvSceneSwitcher.invaildEntriesWillNotBeSaved="无效项将不会被保存"
+AdvSceneSwitcher.selectWindowTip="使用 \"OBS\" 来指定OBS窗口\n使用 \"Task Switching\" 来指定 Alt + Tab"
+
+AdvSceneSwitcher.status.active="运行中"
+AdvSceneSwitcher.status.inactive="已停止"
+
+AdvSceneSwitcher.unit.milliseconds="毫秒"
+AdvSceneSwitcher.unit.secends="秒"
+AdvSceneSwitcher.unit.minutes="分钟"
+AdvSceneSwitcher.unit.hours="小时"
+

src/advanced-scene-switcher-module.c

@@ -1,12 +1,15 @@
 #include <obs-module.h>
+#include <obs-frontend-api.h>
 
 OBS_DECLARE_MODULE()
+OBS_MODULE_USE_DEFAULT_LOCALE("advanced-scene-switcher", "en-US")
 
 void InitSceneSwitcher();
 void FreeSceneSwitcher();
 
 bool obs_module_load(void)
 {
+	obs_frontend_push_ui_translation(obs_module_get_string);
 	InitSceneSwitcher();
 	return true;
 }

src/advanced-scene-switcher.cpp

@@ -1,30 +1,25 @@
 #include <QMainWindow>
-#include <QDir>
 #include <QAction>
+#include <QtGui/qstandarditemmodel.h>
+#include <QPropertyAnimation>
+#include <QGraphicsColorizeEffect>
+#include <QMessageBox>
 
-#include <condition_variable>
-#include <chrono>
-#include <vector>
-#include <mutex>
-#include <thread>
-
-#include <obs-frontend-api.h>
 #include <obs-module.h>
-#include <obs.hpp>
+#include <obs-frontend-api.h>
 #include <util/util.hpp>
 
-#include "headers/switcher-data-structs.hpp"
 #include "headers/advanced-scene-switcher.hpp"
-#include "headers/utility.hpp"
 #include "headers/curl-helper.hpp"
+#include "headers/version.h"
 
 SwitcherData *switcher = nullptr;
 
-/********************************************************************************
+/******************************************************************************
  * Create the Advanced Scene Switcher settings window
- ********************************************************************************/
-SceneSwitcher::SceneSwitcher(QWidget *parent)
-	: QDialog(parent), ui(new Ui_SceneSwitcher)
+ ******************************************************************************/
+AdvSceneSwitcher::AdvSceneSwitcher(QWidget *parent)
+	: QDialog(parent), ui(new Ui_AdvSceneSwitcher)
 {
 	ui->setupUi(this);
 
@@ -34,47 +29,20 @@ SceneSwitcher::SceneSwitcher(QWidget *parent)
 	loadUI();
 }
 
-void SceneSwitcher::populateSceneSelection(QComboBox *sel, bool addPrevious)
+bool translationAvailable()
 {
-	BPtr<char *> scenes = obs_frontend_get_scene_names();
-	char **temp = scenes;
-	while (*temp) {
-		const char *name = *temp;
-		sel->addItem(name);
-		temp++;
-	}
-
-	if (addPrevious)
-		sel->addItem(previous_scene_name);
+	return !!strcmp(obs_module_text("AdvSceneSwitcher.pluginName"),
+			"AdvSceneSwitcher.pluginName");
 }
 
-void SceneSwitcher::populateTransitionSelection(QComboBox *sel)
+void AdvSceneSwitcher::loadUI()
 {
-	obs_frontend_source_list *transitions = new obs_frontend_source_list();
-	obs_frontend_get_transitions(transitions);
-
-	for (size_t i = 0; i < transitions->sources.num; i++) {
-		const char *name =
-			obs_source_get_name(transitions->sources.array[i]);
-		sel->addItem(name);
+	if (!translationAvailable()) {
+		(void)DisplayMessage(
+			"Failed to find plug-in's 'data' directory.\n"
+			"Please check installation instructions!");
 	}
 
-	obs_frontend_source_list_free(transitions);
-}
-
-void SceneSwitcher::populateWindowSelection(QComboBox *sel)
-{
-	std::vector<std::string> windows;
-	GetWindowList(windows);
-	sort(windows.begin(), windows.end());
-
-	for (std::string &window : windows) {
-		sel->addItem(window.c_str());
-	}
-}
-
-void SceneSwitcher::loadUI()
-{
 #if __APPLE__
 	setMinimumHeight(700);
 #endif
@@ -91,15 +59,313 @@ void SceneSwitcher::loadUI()
 	setupFileTab();
 	setupTimeTab();
 	setupAudioTab();
+	setupSceneGroupTab();
+	setupTriggerTab();
 
 	setTabOrder();
 
 	loading = false;
 }
 
-/********************************************************************************
+/******************************************************************************
+ * UI helpers
+ ******************************************************************************/
+bool AdvSceneSwitcher::DisplayMessage(QString msg, bool question)
+{
+	if (question) {
+		QMessageBox::StandardButton reply;
+		reply = QMessageBox::question(
+			nullptr, "Advanced Scene Switcher", msg,
+			QMessageBox::Yes | QMessageBox::No);
+		if (reply == QMessageBox::Yes) {
+			return true;
+		} else {
+			return false;
+		}
+	} else {
+		QMessageBox Msgbox;
+		Msgbox.setWindowTitle("Advanced Scene Switcher");
+		Msgbox.setText(msg);
+		Msgbox.exec();
+	}
+
+	return false;
+}
+
+void addSelectionEntry(QComboBox *sel, const char *description,
+		       const char *tooltip = "")
+{
+	sel->addItem(description);
+
+	if (strcmp(tooltip, "") != 0) {
+		sel->setItemData(0, tooltip, Qt::ToolTipRole);
+	}
+
+	QStandardItemModel *model =
+		qobject_cast<QStandardItemModel *>(sel->model());
+	QModelIndex firstIndex =
+		model->index(0, sel->modelColumn(), sel->rootModelIndex());
+	QStandardItem *firstItem = model->itemFromIndex(firstIndex);
+	firstItem->setSelectable(false);
+	firstItem->setEnabled(false);
+}
+
+void AdvSceneSwitcher::populateSceneSelection(QComboBox *sel, bool addPrevious,
+					      bool addSceneGroup,
+					      bool addSelect,
+					      std::string selectText)
+{
+	sel->clear();
+
+	if (addSelect) {
+		if (selectText.empty()) {
+			addSelectionEntry(
+				sel,
+				obs_module_text("AdvSceneSwitcher.selectScene"),
+				obs_module_text(
+					"AdvSceneSwitcher.invaildEntriesWillNotBeSaved"));
+		} else {
+			addSelectionEntry(sel, selectText.c_str());
+		}
+	}
+
+	BPtr<char *> scenes = obs_frontend_get_scene_names();
+	char **temp = scenes;
+	while (*temp) {
+		const char *name = *temp;
+		sel->addItem(name);
+		temp++;
+	}
+
+	if (addPrevious) {
+		sel->addItem(obs_module_text(
+			"AdvSceneSwitcher.selectPreviousScene"));
+	}
+
+	if (addSceneGroup) {
+		for (auto &sg : switcher->sceneGroups) {
+			sel->addItem(QString::fromStdString(sg.name));
+		}
+	}
+}
+
+void AdvSceneSwitcher::populateTransitionSelection(QComboBox *sel,
+						   bool addSelect)
+{
+	if (addSelect) {
+		addSelectionEntry(
+			sel,
+			obs_module_text("AdvSceneSwitcher.selectTransition"));
+	}
+
+	obs_frontend_source_list *transitions = new obs_frontend_source_list();
+	obs_frontend_get_transitions(transitions);
+
+	for (size_t i = 0; i < transitions->sources.num; i++) {
+		const char *name =
+			obs_source_get_name(transitions->sources.array[i]);
+		sel->addItem(name);
+	}
+
+	obs_frontend_source_list_free(transitions);
+}
+
+void AdvSceneSwitcher::populateWindowSelection(QComboBox *sel, bool addSelect)
+{
+	if (addSelect) {
+		addSelectionEntry(
+			sel, obs_module_text("AdvSceneSwitcher.selectWindow"));
+	}
+
+	std::vector<std::string> windows;
+	GetWindowList(windows);
+	sort(windows.begin(), windows.end());
+
+	for (std::string &window : windows) {
+		sel->addItem(window.c_str());
+	}
+
+#ifdef WIN32
+	sel->setItemData(0, obs_module_text("AdvSceneSwitcher.selectWindowTip"),
+			 Qt::ToolTipRole);
+#endif
+}
+
+void AdvSceneSwitcher::populateAudioSelection(QComboBox *sel, bool addSelect)
+{
+	if (addSelect) {
+		addSelectionEntry(
+			sel,
+			obs_module_text("AdvSceneSwitcher.selectAudioSource"),
+			obs_module_text(
+				"AdvSceneSwitcher.invaildEntriesWillNotBeSaved"));
+	}
+
+	auto sourceEnum = [](void *data, obs_source_t *source) -> bool /* -- */
+	{
+		std::vector<std::string> *list =
+			reinterpret_cast<std::vector<std::string> *>(data);
+		uint32_t flags = obs_source_get_output_flags(source);
+
+		if ((flags & OBS_SOURCE_AUDIO) != 0) {
+			list->push_back(obs_source_get_name(source));
+		}
+		return true;
+	};
+
+	std::vector<std::string> audioSources;
+	obs_enum_sources(sourceEnum, &audioSources);
+	sort(audioSources.begin(), audioSources.end());
+	for (std::string &source : audioSources) {
+		sel->addItem(source.c_str());
+	}
+}
+
+void AdvSceneSwitcher::populateMediaSelection(QComboBox *sel, bool addSelect)
+{
+	if (addSelect) {
+		addSelectionEntry(
+			sel,
+			obs_module_text("AdvSceneSwitcher.selectMediaSource"),
+			obs_module_text(
+				"AdvSceneSwitcher.invaildEntriesWillNotBeSaved"));
+	}
+
+	auto sourceEnum = [](void *data, obs_source_t *source) -> bool /* -- */
+	{
+		std::vector<std::string> *list =
+			reinterpret_cast<std::vector<std::string> *>(data);
+		std::string sourceId = obs_source_get_id(source);
+		if (sourceId.compare("ffmpeg_source") == 0 ||
+		    sourceId.compare("vlc_source") == 0) {
+			list->push_back(obs_source_get_name(source));
+		}
+		return true;
+	};
+
+	std::vector<std::string> mediaSources;
+	obs_enum_sources(sourceEnum, &mediaSources);
+	sort(mediaSources.begin(), mediaSources.end());
+	for (std::string &source : mediaSources) {
+		sel->addItem(source.c_str());
+	}
+}
+
+void AdvSceneSwitcher::populateProcessSelection(QComboBox *sel, bool addSelect)
+{
+	if (addSelect) {
+		addSelectionEntry(
+			sel, obs_module_text("AdvSceneSwitcher.selectProcess"));
+	}
+
+	QStringList processes;
+	GetProcessList(processes);
+	processes.sort();
+	for (QString &process : processes)
+		sel->addItem(process);
+}
+
+void AdvSceneSwitcher::listAddClicked(QListWidget *list,
+				      SwitchWidget *newWidget,
+				      QPushButton *addButton,
+				      QMetaObject::Connection *addHighlight)
+{
+	if (!list || !newWidget) {
+		blog(LOG_WARNING,
+		     "listAddClicked called without valid list or widget");
+		return;
+	}
+
+	if (addButton && addHighlight) {
+		addButton->disconnect(*addHighlight);
+	}
+
+	QListWidgetItem *item;
+	item = new QListWidgetItem(list);
+	list->addItem(item);
+	item->setSizeHint(newWidget->minimumSizeHint());
+	list->setItemWidget(item, newWidget);
+
+	list->scrollToItem(item);
+}
+
+bool AdvSceneSwitcher::listMoveUp(QListWidget *list)
+{
+	int index = list->currentRow();
+	if (index == -1 || index == 0) {
+		return false;
+	}
+
+	QWidget *row = list->itemWidget(list->currentItem());
+	QListWidgetItem *itemN = list->currentItem()->clone();
+
+	list->insertItem(index - 1, itemN);
+	list->setItemWidget(itemN, row);
+
+	list->takeItem(index + 1);
+	list->setCurrentRow(index - 1);
+	return true;
+}
+
+bool AdvSceneSwitcher::listMoveDown(QListWidget *list)
+{
+	int index = list->currentRow();
+	if (index == -1 || index == list->count() - 1) {
+		return false;
+	}
+
+	QWidget *row = list->itemWidget(list->currentItem());
+	QListWidgetItem *itemN = list->currentItem()->clone();
+
+	list->insertItem(index + 2, itemN);
+	list->setItemWidget(itemN, row);
+
+	list->takeItem(index);
+	list->setCurrentRow(index + 1);
+	return true;
+}
+
+QMetaObject::Connection AdvSceneSwitcher::PulseWidget(QWidget *widget,
+						      QColor endColor,
+						      QColor startColor,
+						      QString specifier)
+{
+	if (switcher->disableHints) {
+		return QMetaObject::Connection();
+	}
+
+	widget->setStyleSheet(specifier + "{ \
+		border-style: outset; \
+		border-width: 2px; \
+		border-radius: 10px; \
+		border-color: rgb(0,0,0,0) \
+		}");
+
+	QGraphicsColorizeEffect *eEffect = new QGraphicsColorizeEffect(widget);
+	widget->setGraphicsEffect(eEffect);
+	QPropertyAnimation *paAnimation =
+		new QPropertyAnimation(eEffect, "color");
+	paAnimation->setStartValue(startColor);
+	paAnimation->setEndValue(endColor);
+	paAnimation->setDuration(1000);
+	// Play backwards to return to original state on timer end
+	paAnimation->setDirection(QAbstractAnimation::Backward);
+
+	auto con = QWidget::connect(
+		paAnimation, &QPropertyAnimation::finished, [paAnimation]() {
+			QTimer::singleShot(1000, [paAnimation] {
+				paAnimation->start();
+			});
+		});
+
+	paAnimation->start();
+
+	return con;
+}
+
+/******************************************************************************
  * Saving and loading
- ********************************************************************************/
+ ******************************************************************************/
 static void SaveSceneSwitcher(obs_data_t *save_data, bool saving, void *)
 {
 	if (saving) {
@@ -109,20 +375,7 @@ static void SaveSceneSwitcher(obs_data_t *save_data, bool saving, void *)
 
 		obs_data_t *obj = obs_data_create();
 
-		switcher->saveWindowTitleSwitches(obj);
-		switcher->saveScreenRegionSwitches(obj);
-		switcher->savePauseSwitches(obj);
-		switcher->saveSceneSequenceSwitches(obj);
-		switcher->saveSceneTransitions(obj);
-		switcher->saveIdleSwitches(obj);
-		switcher->saveExecutableSwitches(obj);
-		switcher->saveRandomSwitches(obj);
-		switcher->saveFileSwitches(obj);
-		switcher->saveMediaSwitches(obj);
-		switcher->saveTimeSwitches(obj);
-		switcher->saveAudioSwitches(obj);
-		switcher->saveGeneralSettings(obj);
-		switcher->saveHotkeys(obj);
+		switcher->saveSettings(obj);
 
 		obs_data_set_obj(save_data, "advanced-scene-switcher", obj);
 
@@ -133,88 +386,88 @@ static void SaveSceneSwitcher(obs_data_t *save_data, bool saving, void *)
 		obs_data_t *obj =
 			obs_data_get_obj(save_data, "advanced-scene-switcher");
 
-		if (!obj)
+		if (!obj) {
 			obj = obs_data_create();
+		}
+		if (switcher->versionChanged(obj, g_GIT_SHA1)) {
+			AdvSceneSwitcher::AskBackup(obj);
+		}
 
-		switcher->loadWindowTitleSwitches(obj);
-		switcher->loadScreenRegionSwitches(obj);
-		switcher->loadPauseSwitches(obj);
-		switcher->loadSceneSequenceSwitches(obj);
-		switcher->loadSceneTransitions(obj);
-		switcher->loadIdleSwitches(obj);
-		switcher->loadExecutableSwitches(obj);
-		switcher->loadRandomSwitches(obj);
-		switcher->loadFileSwitches(obj);
-		switcher->loadMediaSwitches(obj);
-		switcher->loadTimeSwitches(obj);
-		switcher->loadAudioSwitches(obj);
-		switcher->loadGeneralSettings(obj);
-		switcher->loadHotkeys(obj);
+		switcher->loadSettings(obj);
 
 		obs_data_release(obj);
 
 		switcher->m.unlock();
 
-		// stop the scene switcher at least once
-		// to avoid issues with scene collection changes
+		// Stop the scene switcher at least once to
+		// avoid scene duplication issues with scene collection changes
 		bool start = !switcher->stop;
 		switcher->Stop();
-		if (start)
+		if (start) {
 			switcher->Start();
+		}
 	}
 }
 
-/********************************************************************************
+/******************************************************************************
  * Main switcher thread
- ********************************************************************************/
+ ******************************************************************************/
 void SwitcherData::Thread()
 {
-	blog(LOG_INFO, "Advanced Scene Switcher started");
+	blog(LOG_INFO, "started");
 	int sleep = 0;
+	int linger = 0;
+	std::chrono::milliseconds duration;
+	auto startTime = std::chrono::high_resolution_clock::now();
+	auto endTime = std::chrono::high_resolution_clock::now();
 
 	while (true) {
-	startLoop:
 		std::unique_lock<std::mutex> lock(m);
+
 		bool match = false;
 		OBSWeakSource scene;
 		OBSWeakSource transition;
-		std::chrono::milliseconds duration;
-		if (sleep > interval) {
+
+		bool defTransitionMatch = false;
+		OBSWeakSource defTransition;
+
+		endTime = std::chrono::high_resolution_clock::now();
+
+		auto runTime =
+			std::chrono::duration_cast<std::chrono::milliseconds>(
+				endTime - startTime);
+
+		if (sleep) {
 			duration = std::chrono::milliseconds(sleep);
-			if (verbose)
-				blog(LOG_INFO,
-				     "Advanced Scene Switcher sleep for %d",
-				     sleep);
 		} else {
-			duration = std::chrono::milliseconds(interval);
-			if (verbose)
+			duration = std::chrono::milliseconds(interval) +
+				   std::chrono::milliseconds(linger) - runTime;
+			if (duration.count() < 1) {
 				blog(LOG_INFO,
-				     "Advanced Scene Switcher sleep for %d",
-				     interval);
+				     "detected busy loop - refusing to sleep less than 1ms");
+				duration = std::chrono::milliseconds(50);
+			}
 		}
-		sleep = 0;
-		switcher->Prune();
-		writeSceneInfoToFile();
-		//sleep for a bit
+
+		vblog(LOG_INFO, "sleep for %ld", duration.count());
 		cv.wait_for(lock, duration);
+
+		startTime = std::chrono::high_resolution_clock::now();
+		sleep = 0;
+		linger = 0;
+
+		switcher->Prune();
+
 		if (switcher->stop) {
 			break;
 		}
 
-		setDefaultSceneTransitions();
-
-		if (autoStopEnable) {
-			autoStopStreamAndRecording();
-		}
-
-		if (autoStartEnable) {
-			autoStartStreamRecording();
-		}
-
 		if (checkPause()) {
 			continue;
 		}
 
+		checkDefaultSceneTransitions(defTransitionMatch, defTransition);
+
 		for (int switchFuncName : functionNamesByPriority) {
 			switch (switchFuncName) {
 			case read_file_func:
@@ -228,7 +481,6 @@ void SwitcherData::Thread()
 			case exe_func:
 				checkExeSwitch(match, scene, transition);
 				break;
-
 			case screen_region_func:
 				checkScreenRegionSwitch(match, scene,
 							transition);
@@ -239,11 +491,7 @@ void SwitcherData::Thread()
 				break;
 			case round_trip_func:
 				checkSceneSequence(match, scene, transition,
-						    lock);
-				if (sceneChangedDuringWait()) //scene might have changed during the sleep
-				{
-					goto startLoop;
-				}
+						   linger);
 				break;
 			case media_func:
 				checkMediaSwitch(match, scene, transition);
@@ -264,65 +512,81 @@ void SwitcherData::Thread()
 			}
 		}
 
-		if (!match && switchIfNotMatching == SWITCH &&
-		    nonMatchingScene) {
-			match = true;
-			scene = nonMatchingScene;
-			transition = nullptr;
+		checkNoMatchSwitch(match, scene, transition, sleep);
+
+		checkSwitchCooldown(match);
+
+		if (linger) {
+			duration = std::chrono::milliseconds(linger);
+			vblog(LOG_INFO, "sleep for %ld before switching scene",
+			      duration.count());
+
+			cv.wait_for(lock, duration);
+
+			if (switcher->stop) {
+				break;
+			}
+
+			if (sceneChangedDuringWait()) {
+				vblog(LOG_INFO,
+				      "scene was changed manually - ignoring match");
+
+				match = false;
+				linger = 0;
+			}
 		}
-		if (!match && switchIfNotMatching == RANDOM_SWITCH) {
-			checkRandom(match, scene, transition, sleep);
+
+		// After this point we will call frontend functions
+		// obs_frontend_set_current_scene() and
+		// obs_frontend_set_current_transition()
+		//
+		// During this time SaveSceneSwitcher() could be called
+		// leading to a deadlock, so we have to unlock()
+		lock.unlock();
+
+		if (!match && defTransitionMatch) {
+			setCurrentDefTransition(defTransition);
 		}
+
 		if (match) {
 			switchScene(scene, transition,
-				    tansitionOverrideOverride, lock);
+				    tansitionOverrideOverride);
 		}
+
+		writeSceneInfoToFile();
 	}
 endLoop:
-	blog(LOG_INFO, "Advanced Scene Switcher stopped");
+	blog(LOG_INFO, "stopped");
 }
 
 void switchScene(OBSWeakSource &scene, OBSWeakSource &transition,
-		 bool &transitionOverrideOverride,
-		 std::unique_lock<std::mutex> &lock)
+		 bool &transitionOverrideOverride)
 {
+	if (!scene && switcher->verbose) {
+		blog(LOG_INFO, "nothing to switch to");
+		return;
+	}
+
 	obs_source_t *source = obs_weak_source_get_source(scene);
 	obs_source_t *currentSource = obs_frontend_get_current_scene();
 
 	if (source && source != currentSource) {
-
-		// this call might block when OBS_FRONTEND_EVENT_SCENE_CHANGED is active and mutex is held
-		// thus unlock mutex to avoid deadlock
-		lock.unlock();
-
 		transitionData td;
 		setNextTransition(scene, currentSource, transition,
 				  transitionOverrideOverride, td);
 		obs_frontend_set_current_scene(source);
-		if (transitionOverrideOverride)
+		if (transitionOverrideOverride) {
 			restoreTransitionOverride(source, td);
-		lock.lock();
+		}
 
-		if (switcher->verbose)
-			blog(LOG_INFO,
-			     "Advanced Scene Switcher switched scene");
+		if (switcher->verbose) {
+			blog(LOG_INFO, "switched scene");
+		}
 	}
 	obs_source_release(currentSource);
 	obs_source_release(source);
 }
 
-bool SwitcherData::sceneChangedDuringWait()
-{
-	bool r = false;
-	obs_source_t *currentSource = obs_frontend_get_current_scene();
-	if (!currentSource)
-		return true;
-	obs_source_release(currentSource);
-	if (waitScene && currentSource != waitScene)
-		r = true;
-	return r;
-}
-
 void SwitcherData::Start()
 {
 	if (!(th && th->isRunning())) {
@@ -330,6 +594,9 @@ void SwitcherData::Start()
 		switcher->th = new SwitcherThread();
 		switcher->th->start(
 			(QThread::Priority)switcher->threadPriority);
+
+		// Will be overwritten quickly but might be useful
+		writeToStatusFile("Advanced Scene Switcher running");
 	}
 }
 
@@ -342,17 +609,30 @@ void SwitcherData::Stop()
 		th->wait();
 		delete th;
 		th = nullptr;
+
+		writeToStatusFile("Advanced Scene Switcher stopped");
 	}
 }
 
-/********************************************************************************
+bool SwitcherData::sceneChangedDuringWait()
+{
+	obs_source_t *currentSource = obs_frontend_get_current_scene();
+	if (!currentSource) {
+		return true;
+	}
+	obs_source_release(currentSource);
+	return (waitScene && currentSource != waitScene);
+}
+
+/******************************************************************************
  * OBS module setup
- ********************************************************************************/
+ ******************************************************************************/
 extern "C" void FreeSceneSwitcher()
 {
 	if (loaded_curl_lib) {
-		if (switcher->curl && f_curl_cleanup)
+		if (switcher->curl && f_curl_cleanup) {
 			f_curl_cleanup(switcher->curl);
+		}
 		delete loaded_curl_lib;
 		loaded_curl_lib = nullptr;
 	}
@@ -363,23 +643,27 @@ extern "C" void FreeSceneSwitcher()
 
 void handleSceneChange(SwitcherData *s)
 {
-	std::lock_guard<std::mutex> lock(s->m);
-	//stop waiting if scene was manually changed
-	if (s->sceneChangedDuringWait())
+	// Stop waiting if scene was manually changed
+	if (s->sceneChangedDuringWait()) {
 		s->cv.notify_one();
+	}
 
-	//set previous scene
+	// Set previous scene
 	obs_source_t *source = obs_frontend_get_current_scene();
 	obs_weak_source_t *ws = obs_source_get_weak_source(source);
 	obs_source_release(source);
 	obs_weak_source_release(ws);
-	if (source && s->PreviousScene2 != ws) {
-		s->previousScene = s->PreviousScene2;
-		s->PreviousScene2 = ws;
+	if (source && s->previousSceneHelper != ws) {
+		s->previousScene = s->previousSceneHelper;
+		s->previousSceneHelper = ws;
 	}
 
-	//reset autostart
-	s->autoStartedRecently = false;
+	switcher->checkTriggers();
+}
+
+void handleTransitionStop(SwitcherData *s)
+{
+	s->checkedDefTransition = false;
 }
 
 void setLiveTime(SwitcherData *s)
@@ -392,6 +676,23 @@ void resetLiveTime(SwitcherData *s)
 	s->liveTime = QDateTime();
 }
 
+void checkAutoStartRecording(SwitcherData *s)
+{
+	if (s->autoStartEvent == AutoStartEvent::RECORDING ||
+	    s->autoStartEvent == AutoStartEvent::RECORINDG_OR_STREAMING)
+		s->Start();
+}
+
+void checkAutoStartStreaming(SwitcherData *s)
+{
+	if (s->autoStartEvent == AutoStartEvent::STREAMING ||
+	    s->autoStartEvent == AutoStartEvent::RECORINDG_OR_STREAMING)
+		s->Start();
+}
+
+// Note to future self:
+// be careful using switcher->m here as there is potential for deadlocks when using
+// frontend functions such as obs_frontend_set_current_scene()
 static void OBSEvent(enum obs_frontend_event event, void *switcher)
 {
 	switch (event) {
@@ -401,9 +702,16 @@ static void OBSEvent(enum obs_frontend_event event, void *switcher)
 	case OBS_FRONTEND_EVENT_SCENE_CHANGED:
 		handleSceneChange((SwitcherData *)switcher);
 		break;
+	case OBS_FRONTEND_EVENT_TRANSITION_STOPPED:
+		handleTransitionStop((SwitcherData *)switcher);
+		break;
 	case OBS_FRONTEND_EVENT_RECORDING_STARTED:
+		setLiveTime((SwitcherData *)switcher);
+		checkAutoStartRecording((SwitcherData *)switcher);
+		break;
 	case OBS_FRONTEND_EVENT_STREAMING_STARTED:
 		setLiveTime((SwitcherData *)switcher);
+		checkAutoStartStreaming((SwitcherData *)switcher);
 		break;
 	case OBS_FRONTEND_EVENT_RECORDING_STOPPED:
 	case OBS_FRONTEND_EVENT_STREAMING_STOPPED:
@@ -416,8 +724,10 @@ static void OBSEvent(enum obs_frontend_event event, void *switcher)
 
 extern "C" void InitSceneSwitcher()
 {
+	blog(LOG_INFO, "version: %s", g_GIT_SHA1);
+
 	QAction *action = (QAction *)obs_frontend_add_tools_menu_qaction(
-		"Advanced Scene Switcher");
+		obs_module_text("AdvSceneSwitcher.pluginName"));
 
 	switcher = new SwitcherData;
 
@@ -429,7 +739,7 @@ extern "C" void InitSceneSwitcher()
 		QMainWindow *window =
 			(QMainWindow *)obs_frontend_get_main_window();
 
-		SceneSwitcher ss(window);
+		AdvSceneSwitcher ss(window);
 		ss.exec();
 	};
 

src/curl-helper.cpp

@@ -23,11 +23,11 @@ bool resolveCurl()
 		(cleanupFunction)loaded_curl_lib->resolve("curl_easy_cleanup");
 
 	if (f_curl_init && f_curl_setopt && f_curl_perform && f_curl_cleanup) {
-		blog(LOG_INFO, "curl loaded successfully");
+		blog(LOG_INFO, "[adv-ss] curl loaded successfully");
 		return true;
 	}
 
-	blog(LOG_INFO, "curl symbols not resolved");
+	blog(LOG_INFO, "[adv-ss] curl symbols not resolved");
 	return false;
 }
 
@@ -43,25 +43,26 @@ bool loadCurl()
 #endif
 
 	for (QString path : locations) {
-		blog(LOG_INFO, "trying '%s'", path.toUtf8().constData());
+		blog(LOG_INFO, "[adv-ss] trying '%s'",
+		     path.toUtf8().constData());
 		QFileInfo libPath(
 			QDir(path).absoluteFilePath(curl_library_name));
 
 		if (libPath.exists() && libPath.isFile()) {
 			QString libFilePath = libPath.absoluteFilePath();
-			blog(LOG_INFO, "found curl library at '%s'",
+			blog(LOG_INFO, "[adv-ss] found curl library at '%s'",
 			     libFilePath.toUtf8().constData());
 
 			loaded_curl_lib = new QLibrary(libFilePath, nullptr);
-			if (resolveCurl())
+			if (resolveCurl()) {
 				return true;
-			else {
+			} else {
 				delete loaded_curl_lib;
 				loaded_curl_lib = nullptr;
 			}
 		}
 	}
 
-	blog(LOG_ERROR, "can't find the curl library");
+	blog(LOG_WARNING, "[adv-ss] can't find the curl library");
 	return false;
 }

src/general.cpp

@@ -1,16 +1,19 @@
-#include <obs-module.h>
 #include <QFileDialog>
-#include <QTextStream>
-#include <QMessageBox>
 
 #include "headers/advanced-scene-switcher.hpp"
+#include "headers/utility.hpp"
+#include "headers/version.h"
 
-void SceneSwitcher::on_close_clicked()
+constexpr auto tab_count = 15;
+
+QMetaObject::Connection inactivePluse;
+
+void AdvSceneSwitcher::on_close_clicked()
 {
 	done(0);
 }
 
-void SceneSwitcher::UpdateNonMatchingScene(const QString &name)
+void AdvSceneSwitcher::UpdateNonMatchingScene(const QString &name)
 {
 	obs_source_t *scene = obs_get_source_by_name(name.toUtf8().constData());
 	obs_weak_source_t *ws = obs_source_get_weak_source(scene);
@@ -21,77 +24,124 @@ void SceneSwitcher::UpdateNonMatchingScene(const QString &name)
 	obs_source_release(scene);
 }
 
-void SceneSwitcher::on_noMatchDontSwitch_clicked()
+void AdvSceneSwitcher::on_noMatchDontSwitch_clicked()
 {
-	if (loading)
+	if (loading) {
 		return;
+	}
 
 	std::lock_guard<std::mutex> lock(switcher->m);
 	switcher->switchIfNotMatching = NO_SWITCH;
 	ui->noMatchSwitchScene->setEnabled(false);
+	ui->randomDisabledWarning->setVisible(true);
 }
 
-void SceneSwitcher::on_noMatchSwitch_clicked()
+void AdvSceneSwitcher::on_noMatchSwitch_clicked()
 {
-	if (loading)
+	if (loading) {
 		return;
+	}
 
 	std::lock_guard<std::mutex> lock(switcher->m);
 	switcher->switchIfNotMatching = SWITCH;
 	ui->noMatchSwitchScene->setEnabled(true);
 	UpdateNonMatchingScene(ui->noMatchSwitchScene->currentText());
+	ui->randomDisabledWarning->setVisible(true);
 }
 
-void SceneSwitcher::on_noMatchRandomSwitch_clicked()
+void AdvSceneSwitcher::on_noMatchRandomSwitch_clicked()
 {
-	if (loading)
+	if (loading) {
 		return;
+	}
 
 	std::lock_guard<std::mutex> lock(switcher->m);
 	switcher->switchIfNotMatching = RANDOM_SWITCH;
 	ui->noMatchSwitchScene->setEnabled(false);
+	ui->randomDisabledWarning->setVisible(false);
 }
 
-void SceneSwitcher::on_startupBehavior_currentIndexChanged(int index)
+void AdvSceneSwitcher::on_noMatchDelay_valueChanged(double i)
 {
-	if (loading)
+	if (loading) {
 		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switcher->noMatchDelay = i;
+}
+
+void AdvSceneSwitcher::on_startupBehavior_currentIndexChanged(int index)
+{
+	if (loading) {
+		return;
+	}
 
 	std::lock_guard<std::mutex> lock(switcher->m);
 	switcher->startupBehavior = (StartupBehavior)index;
 }
 
-void SceneSwitcher::on_noMatchSwitchScene_currentTextChanged(const QString &text)
+void AdvSceneSwitcher::on_autoStartEvent_currentIndexChanged(int index)
 {
-	if (loading)
+	if (loading) {
 		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switcher->autoStartEvent = static_cast<AutoStartEvent>(index);
+}
+
+void AdvSceneSwitcher::on_noMatchSwitchScene_currentTextChanged(
+	const QString &text)
+{
+	if (loading) {
+		return;
+	}
 
 	std::lock_guard<std::mutex> lock(switcher->m);
 	UpdateNonMatchingScene(text);
 }
 
-void SceneSwitcher::on_checkInterval_valueChanged(int value)
+void AdvSceneSwitcher::on_cooldownTime_valueChanged(double i)
 {
-	if (loading)
+	if (loading) {
 		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switcher->cooldown = i;
+}
+
+void AdvSceneSwitcher::on_checkInterval_valueChanged(int value)
+{
+	if (loading) {
+		return;
+	}
 
 	std::lock_guard<std::mutex> lock(switcher->m);
 	switcher->interval = value;
 }
 
-void SceneSwitcher::SetStarted()
+void AdvSceneSwitcher::SetStarted()
 {
-	ui->toggleStartButton->setText("Stop");
-	ui->pluginRunningText->setText("Active");
+	ui->toggleStartButton->setText(
+		obs_module_text("AdvSceneSwitcher.generalTab.status.stop"));
+	ui->pluginRunningText->setText(
+		obs_module_text("AdvSceneSwitcher.status.active"));
+	ui->pluginRunningText->disconnect(inactivePluse);
 }
 
-void SceneSwitcher::SetStopped()
+void AdvSceneSwitcher::SetStopped()
 {
-	ui->toggleStartButton->setText("Start");
-	ui->pluginRunningText->setText("Inactive");
+	ui->toggleStartButton->setText(
+		obs_module_text("AdvSceneSwitcher.generalTab.status.start"));
+	ui->pluginRunningText->setText(
+		obs_module_text("AdvSceneSwitcher.status.inactive"));
+	inactivePluse = PulseWidget(ui->pluginRunningText, QColor(Qt::red),
+				    QColor(0, 0, 0, 0), "QLabel ");
 }
 
-void SceneSwitcher::on_toggleStartButton_clicked()
+void AdvSceneSwitcher::on_toggleStartButton_clicked()
 {
 	if (switcher->th && switcher->th->isRunning()) {
 		switcher->Stop();
@@ -102,204 +152,236 @@ void SceneSwitcher::on_toggleStartButton_clicked()
 	}
 }
 
-void SceneSwitcher::closeEvent(QCloseEvent *)
+void AdvSceneSwitcher::closeEvent(QCloseEvent *)
 {
 	obs_frontend_save();
 }
 
-void SceneSwitcher::on_autoStopScenes_currentTextChanged(const QString &text)
+void AdvSceneSwitcher::on_verboseLogging_stateChanged(int state)
 {
-	if (loading)
+	if (loading) {
 		return;
-
-	std::lock_guard<std::mutex> lock(switcher->m);
-	UpdateAutoStopScene(text);
-}
-
-void SceneSwitcher::on_autoStopSceneCheckBox_stateChanged(int state)
-{
-	if (loading)
-		return;
-
-	std::lock_guard<std::mutex> lock(switcher->m);
-	if (!state) {
-		ui->autoStopScenes->setDisabled(true);
-		switcher->autoStopEnable = false;
-	} else {
-		ui->autoStopScenes->setDisabled(false);
-		switcher->autoStopEnable = true;
-		if (!switcher->autoStopScene)
-			UpdateAutoStopScene(ui->autoStopScenes->currentText());
 	}
-}
 
-void SceneSwitcher::UpdateAutoStopScene(const QString &name)
-{
-	obs_source_t *scene = obs_get_source_by_name(name.toUtf8().constData());
-	obs_weak_source_t *ws = obs_source_get_weak_source(scene);
-
-	switcher->autoStopScene = ws;
-
-	obs_weak_source_release(ws);
-	obs_source_release(scene);
-}
-
-void SwitcherData::autoStopStreamAndRecording()
-{
-	obs_source_t *currentSource = obs_frontend_get_current_scene();
-	obs_weak_source_t *ws = obs_source_get_weak_source(currentSource);
-
-	if (ws && autoStopScene == ws) {
-		if (obs_frontend_streaming_active())
-			obs_frontend_streaming_stop();
-		if (obs_frontend_recording_active())
-			obs_frontend_recording_stop();
-	}
-	obs_source_release(currentSource);
-	obs_weak_source_release(ws);
-}
-
-void SceneSwitcher::on_autoStartType_currentIndexChanged(int index)
-{
-	if (loading)
-		return;
-	std::lock_guard<std::mutex> lock(switcher->m);
-	switcher->autoStartType = (AutoStartType)index;
-}
-
-void SceneSwitcher::on_autoStartScenes_currentTextChanged(const QString &text)
-{
-	if (loading)
-		return;
-
-	std::lock_guard<std::mutex> lock(switcher->m);
-	UpdateAutoStartScene(text);
-}
-
-void SceneSwitcher::on_autoStartSceneCheckBox_stateChanged(int state)
-{
-	if (loading)
-		return;
-
-	std::lock_guard<std::mutex> lock(switcher->m);
-	if (!state) {
-		ui->autoStartScenes->setDisabled(true);
-		ui->autoStartType->setDisabled(true);
-		switcher->autoStartEnable = false;
-	} else {
-		ui->autoStartScenes->setDisabled(false);
-		ui->autoStartType->setDisabled(false);
-		switcher->autoStartEnable = true;
-		if (!switcher->autoStartScene)
-			UpdateAutoStartScene(
-				ui->autoStartScenes->currentText());
-	}
-}
-
-void SceneSwitcher::UpdateAutoStartScene(const QString &name)
-{
-	obs_source_t *scene = obs_get_source_by_name(name.toUtf8().constData());
-	obs_weak_source_t *ws = obs_source_get_weak_source(scene);
-
-	switcher->autoStartScene = ws;
-
-	obs_weak_source_release(ws);
-	obs_source_release(scene);
-}
-
-void SwitcherData::autoStartStreamRecording()
-{
-	if (autoStartedRecently)
-		return;
-
-	obs_source_t *currentSource = obs_frontend_get_current_scene();
-	obs_weak_source_t *ws = obs_source_get_weak_source(currentSource);
-
-	if (ws && autoStartScene == ws) {
-		if ((switcher->autoStartType == STREAMING ||
-		     switcher->autoStartType == RECORINDGSTREAMING) &&
-		    !obs_frontend_streaming_active())
-			obs_frontend_streaming_start();
-		if ((switcher->autoStartType == RECORDING ||
-		     switcher->autoStartType == RECORINDGSTREAMING) &&
-		    !obs_frontend_recording_active())
-			obs_frontend_recording_start();
-	}
-	obs_source_release(currentSource);
-	obs_weak_source_release(ws);
-
-	autoStartedRecently = true;
-}
-
-void SceneSwitcher::on_verboseLogging_stateChanged(int state)
-{
-	if (loading)
-		return;
-
-	std::lock_guard<std::mutex> lock(switcher->m);
 	switcher->verbose = state;
 }
 
-void SceneSwitcher::on_exportSettings_clicked()
+void AdvSceneSwitcher::on_uiHintsDisable_stateChanged(int state)
 {
-	QString directory = QFileDialog::getSaveFileName(
-		this, tr("Export Advanced Scene Switcher settings to file ..."),
-		QDir::currentPath(), tr("Text files (*.txt)"));
-	if (directory.isEmpty())
+	if (loading) {
 		return;
+	}
+
+	switcher->disableHints = state;
+}
+
+void AdvSceneSwitcher::AskBackup(obs_data_t *obj)
+{
+	bool backupSettings = DisplayMessage(
+		obs_module_text("AdvSceneSwitcher.askBackup"), true);
+
+	if (!backupSettings) {
+		return;
+	}
+
+	QString directory = QFileDialog::getSaveFileName(
+		nullptr,
+		obs_module_text(
+			"AdvSceneSwitcher.generalTab.saveOrLoadsettings.importWindowTitle"),
+		QDir::currentPath(),
+		obs_module_text(
+			"AdvSceneSwitcher.generalTab.saveOrLoadsettings.textType"));
+	if (directory.isEmpty()) {
+		return;
+	}
 
 	QFile file(directory);
-	if (!file.open(QIODevice::WriteOnly | QIODevice::Text))
+	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")),
+		QDir::currentPath(),
+		tr(obs_module_text(
+			"AdvSceneSwitcher.generalTab.saveOrLoadsettings.textType")));
+	if (directory.isEmpty()) {
+		return;
+	}
+
+	QFile file(directory);
+	if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
+		return;
+	}
 
 	obs_data_t *obj = obs_data_create();
 
-	switcher->saveWindowTitleSwitches(obj);
-	switcher->saveScreenRegionSwitches(obj);
-	switcher->savePauseSwitches(obj);
-	switcher->saveSceneSequenceSwitches(obj);
-	switcher->saveSceneTransitions(obj);
-	switcher->saveIdleSwitches(obj);
-	switcher->saveExecutableSwitches(obj);
-	switcher->saveRandomSwitches(obj);
-	switcher->saveFileSwitches(obj);
-	switcher->saveMediaSwitches(obj);
-	switcher->saveTimeSwitches(obj);
-	switcher->saveAudioSwitches(obj);
-	switcher->saveGeneralSettings(obj);
-	switcher->saveHotkeys(obj);
+	switcher->saveSettings(obj);
 
 	obs_data_save_json(obj, file.fileName().toUtf8().constData());
 
 	obs_data_release(obj);
 }
 
-void SceneSwitcher::on_importSettings_clicked()
+void AdvSceneSwitcher::on_importSettings_clicked()
 {
+	// Scene switcher could be stuck in a sequence
+	// so it needs to be stopped before importing new settings
+	bool start = !switcher->stop;
+	switcher->Stop();
+
 	std::lock_guard<std::mutex> lock(switcher->m);
 
 	QString directory = QFileDialog::getOpenFileName(
 		this,
-		tr("Import Advanced Scene Switcher settings from file ..."),
-		QDir::currentPath(), tr("Text files (*.txt)"));
-	if (directory.isEmpty())
+		tr(obs_module_text(
+			"AdvSceneSwitcher.generalTab.saveOrLoadsettings.importWindowTitle")),
+		QDir::currentPath(),
+		tr(obs_module_text(
+			"AdvSceneSwitcher.generalTab.saveOrLoadsettings.textType")));
+	if (directory.isEmpty()) {
 		return;
+	}
 
 	QFile file(directory);
-	if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
+	if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
 		return;
+	}
 
 	obs_data_t *obj = obs_data_create_from_json_file(
 		file.fileName().toUtf8().constData());
 
 	if (!obj) {
-		QMessageBox Msgbox;
-		Msgbox.setText(
-			"Advanced Scene Switcher failed to import settings");
-		Msgbox.exec();
+		(void)DisplayMessage(obs_module_text(
+			"AdvSceneSwitcher.generalTab.saveOrLoadsettings.loadFail"));
 		return;
 	}
 
+	switcher->loadSettings(obj);
+
+	obs_data_release(obj);
+
+	(void)DisplayMessage(obs_module_text(
+		"AdvSceneSwitcher.generalTab.saveOrLoadsettings.loadSuccess"));
+	close();
+
+	// Restart scene switcher if it was active
+	if (start) {
+		switcher->Start();
+	}
+}
+
+int findTabIndex(QTabWidget *tabWidget, int pos)
+{
+	int at = -1;
+
+	QString tabName = "";
+	switch (pos) {
+	case 0:
+		tabName = "generalTab";
+		break;
+	case 1:
+		tabName = "transitionsTab";
+		break;
+	case 2:
+		tabName = "pauseTab";
+		break;
+	case 3:
+		tabName = "windowTitleTab";
+		break;
+	case 4:
+		tabName = "executableTab";
+		break;
+	case 5:
+		tabName = "screenRegionTab";
+		break;
+	case 6:
+		tabName = "mediaTab";
+		break;
+	case 7:
+		tabName = "fileTab";
+		break;
+	case 8:
+		tabName = "randomTab";
+		break;
+	case 9:
+		tabName = "timeTab";
+		break;
+	case 10:
+		tabName = "idleTab";
+		break;
+	case 11:
+		tabName = "sceneSequenceTab";
+		break;
+	case 12:
+		tabName = "audioTab";
+		break;
+	case 13:
+		tabName = "sceneGroupTab";
+		break;
+	case 14:
+		tabName = "sceneTriggerTab";
+		break;
+	}
+
+	QWidget *page = tabWidget->findChild<QWidget *>(tabName);
+	if (page) {
+		at = tabWidget->indexOf(page);
+	}
+	if (at == -1) {
+		blog(LOG_INFO, "failed to find tab %s",
+		     tabName.toUtf8().constData());
+	}
+
+	return at;
+}
+
+void AdvSceneSwitcher::setTabOrder()
+{
+	QTabBar *bar = ui->tabWidget->tabBar();
+	for (int i = 0; i < bar->count(); ++i) {
+		int curPos = findTabIndex(ui->tabWidget, switcher->tabOrder[i]);
+
+		if (i != curPos && curPos != -1) {
+			bar->moveTab(curPos, i);
+		}
+	}
+
+	connect(bar, &QTabBar::tabMoved, this, &AdvSceneSwitcher::on_tabMoved);
+}
+
+void AdvSceneSwitcher::on_tabMoved(int from, int to)
+{
+	if (loading) {
+		return;
+	}
+
+	std::swap(switcher->tabOrder[from], switcher->tabOrder[to]);
+}
+
+void AdvSceneSwitcher::on_tabWidget_currentChanged(int index)
+{
+	UNUSED_PARAMETER(index);
+
+	switcher->showFrame = false;
+	clearFrames(ui->screenRegionSwitches);
+	SetShowFrames();
+}
+
+void SwitcherData::loadSettings(obs_data_t *obj)
+{
+	if (!obj) {
+		return;
+	}
+
+	switcher->loadSceneGroups(obj);
 	switcher->loadWindowTitleSwitches(obj);
 	switcher->loadScreenRegionSwitches(obj);
 	switcher->loadPauseSwitches(obj);
@@ -312,96 +394,34 @@ void SceneSwitcher::on_importSettings_clicked()
 	switcher->loadMediaSwitches(obj);
 	switcher->loadTimeSwitches(obj);
 	switcher->loadAudioSwitches(obj);
+	switcher->loadSceneTriggers(obj);
 	switcher->loadGeneralSettings(obj);
 	switcher->loadHotkeys(obj);
-
-	obs_data_release(obj);
-
-	QMessageBox Msgbox;
-	Msgbox.setText(
-		"Advanced Scene Switcher settings imported successfully");
-	Msgbox.exec();
-	close();
 }
 
-int findTabIndex(QTabBar *bar, int pos)
+void SwitcherData::saveSettings(obs_data_t *obj)
 {
-	int at = -1;
-
-	QString tabName = "";
-	switch (pos) {
-	case 0:
-		tabName = "General";
-		break;
-	case 1:
-		tabName = "Transition";
-		break;
-	case 2:
-		tabName = "Pause";
-		break;
-	case 3:
-		tabName = "Title";
-		break;
-	case 4:
-		tabName = "Executable";
-		break;
-	case 5:
-		tabName = "Region";
-		break;
-	case 6:
-		tabName = "Media";
-		break;
-	case 7:
-		tabName = "File";
-		break;
-	case 8:
-		tabName = "Random";
-		break;
-	case 9:
-		tabName = "Time";
-		break;
-	case 10:
-		tabName = "Idle";
-		break;
-	case 11:
-		tabName = "Sequence";
-		break;
-	case 12:
-		tabName = "Audio";
-		break;
-	}
-
-	for (int i = 0; i < bar->count(); ++i) {
-		if (bar->tabText(i).compare(tabName) == 0) {
-			at = i;
-			break;
-		}
-	}
-	if (at == -1)
-		blog(LOG_INFO, "Advanced Scene Switcher failed to find tab %s",
-		     tabName.toUtf8().constData());
-
-	return at;
-}
-
-void SceneSwitcher::setTabOrder()
-{
-	QTabBar *bar = ui->tabWidget->tabBar();
-	for (int i = 0; i < bar->count(); ++i) {
-		int curPos = findTabIndex(bar, switcher->tabOrder[i]);
-
-		if (i != curPos && curPos != -1)
-			bar->moveTab(curPos, i);
-	}
-
-	connect(bar, &QTabBar::tabMoved, this, &SceneSwitcher::on_tabMoved);
-}
-
-void SceneSwitcher::on_tabMoved(int from, int to)
-{
-	if (loading)
+	if (!obj) {
 		return;
-	std::swap(switcher->tabOrder[from], switcher->tabOrder[to]);
+	}
+
+	saveSceneGroups(obj);
+	saveWindowTitleSwitches(obj);
+	saveScreenRegionSwitches(obj);
+	savePauseSwitches(obj);
+	saveSceneSequenceSwitches(obj);
+	saveSceneTransitions(obj);
+	saveIdleSwitches(obj);
+	saveExecutableSwitches(obj);
+	saveRandomSwitches(obj);
+	saveFileSwitches(obj);
+	saveMediaSwitches(obj);
+	saveTimeSwitches(obj);
+	saveAudioSwitches(obj);
+	saveSceneTriggers(obj);
+	saveGeneralSettings(obj);
+	saveHotkeys(obj);
+	saveVersion(obj, g_GIT_SHA1);
 }
 
 void SwitcherData::saveGeneralSettings(obs_data_t *obj)
@@ -414,24 +434,18 @@ void SwitcherData::saveGeneralSettings(obs_data_t *obj)
 			    nonMatchingSceneName.c_str());
 	obs_data_set_int(obj, "switch_if_not_matching",
 			 switcher->switchIfNotMatching);
+	obs_data_set_double(obj, "noMatchDelay", switcher->noMatchDelay);
+
+	obs_data_set_double(obj, "cooldown", switcher->cooldown);
 
 	obs_data_set_bool(obj, "active", !switcher->stop);
 	obs_data_set_int(obj, "startup_behavior", switcher->startupBehavior);
 
-	std::string autoStopSceneName =
-		GetWeakSourceName(switcher->autoStopScene);
-	obs_data_set_bool(obj, "autoStopEnable", switcher->autoStopEnable);
-	obs_data_set_string(obj, "autoStopSceneName",
-			    autoStopSceneName.c_str());
-
-	std::string autoStartSceneName =
-		GetWeakSourceName(switcher->autoStartScene);
-	obs_data_set_bool(obj, "autoStartEnable", switcher->autoStartEnable);
-	obs_data_set_int(obj, "autoStartType", switcher->autoStartType);
-	obs_data_set_string(obj, "autoStartSceneName",
-			    autoStartSceneName.c_str());
+	obs_data_set_int(obj, "autoStartEvent",
+			 static_cast<int>(switcher->autoStartEvent));
 
 	obs_data_set_bool(obj, "verbose", switcher->verbose);
+	obs_data_set_bool(obj, "disableHints", switcher->disableHints);
 
 	obs_data_set_int(obj, "priority0",
 			 switcher->functionNamesByPriority[0]);
@@ -454,6 +468,14 @@ void SwitcherData::saveGeneralSettings(obs_data_t *obj)
 
 	obs_data_set_int(obj, "threadPriority", switcher->threadPriority);
 
+	// After fresh install of OBS the vector can be empty
+	// as save() might be called before first load()
+	if (switcher->tabOrder.size() < tab_count) {
+		switcher->tabOrder = std::vector<int>(tab_count);
+		std::iota(switcher->tabOrder.begin(), switcher->tabOrder.end(),
+			  0);
+	}
+
 	obs_data_set_int(obj, "generalTabPos", switcher->tabOrder[0]);
 	obs_data_set_int(obj, "transitionTabPos", switcher->tabOrder[1]);
 	obs_data_set_int(obj, "pauseTabPos", switcher->tabOrder[2]);
@@ -467,6 +489,8 @@ void SwitcherData::saveGeneralSettings(obs_data_t *obj)
 	obs_data_set_int(obj, "idleTabPos", switcher->tabOrder[10]);
 	obs_data_set_int(obj, "sequenceTabPos", switcher->tabOrder[11]);
 	obs_data_set_int(obj, "audioTabPos", switcher->tabOrder[12]);
+	obs_data_set_int(obj, "sceneGroupTabPos", switcher->tabOrder[13]);
+	obs_data_set_int(obj, "triggerTabPos", switcher->tabOrder[14]);
 }
 
 void SwitcherData::loadGeneralSettings(obs_data_t *obj)
@@ -481,28 +505,25 @@ void SwitcherData::loadGeneralSettings(obs_data_t *obj)
 		obs_data_get_string(obj, "non_matching_scene");
 	switcher->nonMatchingScene =
 		GetWeakSourceByName(nonMatchingScene.c_str());
+	switcher->noMatchDelay = obs_data_get_double(obj, "noMatchDelay");
+
+	switcher->cooldown = obs_data_get_double(obj, "cooldown");
 
 	switcher->stop = !obs_data_get_bool(obj, "active");
 	switcher->startupBehavior =
 		(StartupBehavior)obs_data_get_int(obj, "startup_behavior");
-	if (switcher->startupBehavior == START)
+	if (switcher->startupBehavior == START) {
 		switcher->stop = false;
-	if (switcher->startupBehavior == STOP)
+	}
+	if (switcher->startupBehavior == STOP) {
 		switcher->stop = true;
+	}
 
-	std::string autoStopScene =
-		obs_data_get_string(obj, "autoStopSceneName");
-	switcher->autoStopEnable = obs_data_get_bool(obj, "autoStopEnable");
-	switcher->autoStopScene = GetWeakSourceByName(autoStopScene.c_str());
-
-	std::string autoStartScene =
-		obs_data_get_string(obj, "autoStartSceneName");
-	switcher->autoStartEnable = obs_data_get_bool(obj, "autoStartEnable");
-	switcher->autoStartType =
-		(AutoStartType)obs_data_get_int(obj, "autoStartType");
-	switcher->autoStartScene = GetWeakSourceByName(autoStartScene.c_str());
+	switcher->autoStartEvent = static_cast<AutoStartEvent>(
+		obs_data_get_int(obj, "autoStartEvent"));
 
 	switcher->verbose = obs_data_get_bool(obj, "verbose");
+	switcher->disableHints = obs_data_get_bool(obj, "disableHints");
 
 	obs_data_set_default_int(obj, "priority0", default_priority_0);
 	obs_data_set_default_int(obj, "priority1", default_priority_1);
@@ -561,6 +582,8 @@ void SwitcherData::loadGeneralSettings(obs_data_t *obj)
 	obs_data_set_default_int(obj, "idleTabPos", 10);
 	obs_data_set_default_int(obj, "sequenceTabPos", 11);
 	obs_data_set_default_int(obj, "audioTabPos", 12);
+	obs_data_set_default_int(obj, "sceneGroupTabPos", 13);
+	obs_data_set_default_int(obj, "triggerTabPos", 14);
 
 	switcher->tabOrder.emplace_back(
 		(int)(obs_data_get_int(obj, "generalTabPos")));
@@ -588,13 +611,79 @@ void SwitcherData::loadGeneralSettings(obs_data_t *obj)
 		(int)(obs_data_get_int(obj, "sequenceTabPos")));
 	switcher->tabOrder.emplace_back(
 		(int)(obs_data_get_int(obj, "audioTabPos")));
+	switcher->tabOrder.emplace_back(
+		(int)(obs_data_get_int(obj, "sceneGroupTabPos")));
+	switcher->tabOrder.emplace_back(
+		(int)(obs_data_get_int(obj, "triggerTabPos")));
 }
 
-void SceneSwitcher::setupGeneralTab()
+void SwitcherData::checkNoMatchSwitch(bool &match, OBSWeakSource &scene,
+				      OBSWeakSource &transition, int &sleep)
+{
+	if (match) {
+		noMatchCount = 0;
+		return;
+	}
+
+	if ((noMatchCount * interval) / 1000.0 < noMatchDelay) {
+		noMatchCount++;
+		return;
+	}
+
+	if (switchIfNotMatching == SWITCH && nonMatchingScene) {
+		match = true;
+		scene = nonMatchingScene;
+		transition = nullptr;
+	}
+	if (switchIfNotMatching == RANDOM_SWITCH) {
+		checkRandom(match, scene, transition, sleep);
+	}
+}
+
+void SwitcherData::checkSwitchCooldown(bool &match)
+{
+	if (!match || cooldown == 0.) {
+		return;
+	}
+
+	auto now = std::chrono::high_resolution_clock::now();
+	auto timePassed = std::chrono::duration_cast<std::chrono::milliseconds>(
+		now - lastMatchTime);
+
+	if (timePassed.count() > cooldown * 1000) {
+		lastMatchTime = now;
+		return;
+	}
+
+	match = false;
+	vblog(LOG_INFO, "cooldown active - ignoring match");
+}
+
+void populateStartupBehavior(QComboBox *cb)
+{
+	cb->addItem(obs_module_text(
+		"AdvSceneSwitcher.generalTab.status.onStartup.asLastRun"));
+	cb->addItem(obs_module_text(
+		"AdvSceneSwitcher.generalTab.status.onStartup.alwaysStart"));
+	cb->addItem(obs_module_text(
+		"AdvSceneSwitcher.generalTab.status.onStartup.doNotStart"));
+}
+
+void populateAutoStartEventSelection(QComboBox *cb)
+{
+	cb->addItem(obs_module_text(
+		"AdvSceneSwitcher.generalTab.status.autoStart.never"));
+	cb->addItem(obs_module_text(
+		"AdvSceneSwitcher.generalTab.status.autoStart.recording"));
+	cb->addItem(obs_module_text(
+		"AdvSceneSwitcher.generalTab.status.autoStart.streaming"));
+	cb->addItem(obs_module_text(
+		"AdvSceneSwitcher.generalTab.status.autoStart.recordingAndStreaming"));
+}
+
+void AdvSceneSwitcher::setupGeneralTab()
 {
 	populateSceneSelection(ui->noMatchSwitchScene, false);
-	populateSceneSelection(ui->autoStopScenes, false);
-	populateSceneSelection(ui->autoStartScenes, false);
 
 	if (switcher->switchIfNotMatching == SWITCH) {
 		ui->noMatchSwitch->setChecked(true);
@@ -608,66 +697,56 @@ void SceneSwitcher::setupGeneralTab()
 	}
 	ui->noMatchSwitchScene->setCurrentText(
 		GetWeakSourceName(switcher->nonMatchingScene).c_str());
+	ui->noMatchDelay->setValue(switcher->noMatchDelay);
+	ui->noMatchDelay->setToolTip(obs_module_text(
+		"AdvSceneSwitcher.generalTab.generalBehavior.onNoMetDelayTooltip"));
 	ui->checkInterval->setValue(switcher->interval);
 
-	ui->autoStopSceneCheckBox->setChecked(switcher->autoStopEnable);
-	ui->autoStopScenes->setCurrentText(
-		GetWeakSourceName(switcher->autoStopScene).c_str());
-
-	if (ui->autoStopSceneCheckBox->checkState()) {
-		ui->autoStopScenes->setDisabled(false);
-	} else {
-		ui->autoStopScenes->setDisabled(true);
-	}
-
-	ui->autoStartType->addItem("Recording");
-	ui->autoStartType->addItem("Streaming");
-	ui->autoStartType->addItem("Recording and Streaming");
-
-	ui->autoStartSceneCheckBox->setChecked(switcher->autoStartEnable);
-	ui->autoStartScenes->setCurrentText(
-		GetWeakSourceName(switcher->autoStartScene).c_str());
-	ui->autoStartType->setCurrentIndex(switcher->autoStartType);
-
-	if (ui->autoStartSceneCheckBox->checkState()) {
-		ui->autoStartScenes->setDisabled(false);
-		ui->autoStartType->setDisabled(false);
-	} else {
-		ui->autoStartScenes->setDisabled(true);
-		ui->autoStartType->setDisabled(true);
-	}
+	ui->cooldownTime->setValue(switcher->cooldown);
+	ui->cooldownTime->setToolTip(obs_module_text(
+		"AdvSceneSwitcher.generalTab.generalBehavior.cooldownHint"));
 
 	ui->verboseLogging->setChecked(switcher->verbose);
+	ui->uiHintsDisable->setChecked(switcher->disableHints);
 
 	for (int p : switcher->functionNamesByPriority) {
 		std::string s = "";
 		switch (p) {
 		case read_file_func:
-			s = "File Content";
+			s = obs_module_text(
+				"AdvSceneSwitcher.generalTab.priority.fileContent");
 			break;
 		case round_trip_func:
-			s = "Scene Sequence";
+			s = obs_module_text(
+				"AdvSceneSwitcher.generalTab.priority.sceneSequence");
 			break;
 		case idle_func:
-			s = "Idle Detection";
+			s = obs_module_text(
+				"AdvSceneSwitcher.generalTab.priority.idleDetection");
 			break;
 		case exe_func:
-			s = "Executable";
+			s = obs_module_text(
+				"AdvSceneSwitcher.generalTab.priority.executable");
 			break;
 		case screen_region_func:
-			s = "Screen Region";
+			s = obs_module_text(
+				"AdvSceneSwitcher.generalTab.priority.screenRegion");
 			break;
 		case window_title_func:
-			s = "Window Title";
+			s = obs_module_text(
+				"AdvSceneSwitcher.generalTab.priority.windowTitle");
 			break;
 		case media_func:
-			s = "Media";
+			s = obs_module_text(
+				"AdvSceneSwitcher.generalTab.priority.media");
 			break;
 		case time_func:
-			s = "Time";
+			s = obs_module_text(
+				"AdvSceneSwitcher.generalTab.priority.time");
 			break;
 		case audio_func:
-			s = "Audio";
+			s = obs_module_text(
+				"AdvSceneSwitcher.generalTab.priority.audio");
 			break;
 		}
 		QString text(s.c_str());
@@ -689,15 +768,16 @@ void SceneSwitcher::setupGeneralTab()
 		}
 	}
 
-	ui->startupBehavior->addItem(
-		"Start the scene switcher if it was running");
-	ui->startupBehavior->addItem("Always start the scene switcher");
-	ui->startupBehavior->addItem("Do not start the scene switcher");
-
+	populateStartupBehavior(ui->startupBehavior);
 	ui->startupBehavior->setCurrentIndex(switcher->startupBehavior);
 
-	if (switcher->th && switcher->th->isRunning())
+	populateAutoStartEventSelection(ui->autoStartEvent);
+	ui->autoStartEvent->setCurrentIndex(
+		static_cast<int>(switcher->autoStartEvent));
+
+	if (switcher->th && switcher->th->isRunning()) {
 		SetStarted();
-	else
+	} else {
 		SetStopped();
+	}
 }

src/headers/advanced-scene-switcher.hpp

@@ -1,63 +1,47 @@
 #pragma once
-
-#include <QDialog>
-#include <memory>
-#include <vector>
-#include <string>
 #ifdef BUILD_OUT_OF_TREE
 #include "../../forms/ui_advanced-scene-switcher.h"
 #else
 #include "ui_advanced-scene-switcher.h"
 #endif
 #include "switcher-data-structs.hpp"
-#include "volume-control.hpp"
+
+#define blog(level, msg, ...) blog(level, "[adv-ss] " msg, ##__VA_ARGS__)
+#define vblog(level, msg, ...)                               \
+	if (verbose) {                                       \
+		blog(level, "[adv-ss] " msg, ##__VA_ARGS__); \
+	}
 
 class QCloseEvent;
 
 /*******************************************************************************
  * Advanced Scene Switcher window
  *******************************************************************************/
-class SceneSwitcher : public QDialog {
+class AdvSceneSwitcher : public QDialog {
 	Q_OBJECT
 
 public:
-	std::unique_ptr<Ui_SceneSwitcher> ui;
-	VolControl *volMeter = nullptr;
+	std::unique_ptr<Ui_AdvSceneSwitcher> ui;
 	bool loading = true;
 
-	SceneSwitcher(QWidget *parent);
+	AdvSceneSwitcher(QWidget *parent);
 
 	void closeEvent(QCloseEvent *event) override;
 
 	void SetStarted();
 	void SetStopped();
 
-	int FindByData(const QString &window);
-	int ScreenRegionFindByData(const QString &region);
-	int PauseScenesFindByData(const QString &scene);
-	int PauseWindowsFindByData(const QString &window);
+	void SetShowFrames();
+	void SetHideFrames();
+	void clearFrames(QListWidget *list);
+
 	int IgnoreWindowsFindByData(const QString &window);
-	int SceneSequenceFindByData(const QString &scene1);
-	int SceneTransitionsFindByData(const QString &scene1,
-				       const QString &scene2);
-	int DefaultTransitionsFindByData(const QString &scene);
-	int executableFindByData(const QString &exe);
 	int IgnoreIdleWindowsFindByData(const QString &window);
-	int randomFindByData(const QString &scene);
-	int timeFindByData(const timeTrigger &trigger, const QTime &time);
-	int audioFindByData(const QString &source, const int &volume);
 
 	void UpdateNonMatchingScene(const QString &name);
-	void UpdateAutoStopScene(const QString &name);
-	void UpdateAutoStartScene(const QString &name);
-	void UpdateIdleDataTransition(const QString &name);
-	void UpdateIdleDataScene(const QString &name);
-	void SetAudioVolumeMeter(const QString &name);
+	void SetEditSceneGroup(SceneGroup &sg);
 
 	void loadUI();
-	void populateSceneSelection(QComboBox *sel, bool addPrevious);
-	void populateTransitionSelection(QComboBox *sel);
-	void populateWindowSelection(QComboBox *sel);
 	void setupGeneralTab();
 	void setupTitleTab();
 	void setupExecutableTab();
@@ -71,73 +55,103 @@ public:
 	void setupFileTab();
 	void setupTimeTab();
 	void setupAudioTab();
+	void setupSceneGroupTab();
+	void setupTriggerTab();
 	void setTabOrder();
 
+	static bool DisplayMessage(QString msg, bool question = false);
+	static void AskBackup(obs_data_t *obj);
+
+	static void populateSceneSelection(QComboBox *sel,
+					   bool addPrevious = false,
+					   bool addSceneGroup = false,
+					   bool addSelect = true,
+					   std::string selectText = "");
+
+	static void populateTransitionSelection(QComboBox *sel,
+						bool addSelect = true);
+	static void populateWindowSelection(QComboBox *sel,
+					    bool addSelect = true);
+	static void populateAudioSelection(QComboBox *sel,
+					   bool addSelect = true);
+	static void populateMediaSelection(QComboBox *sel,
+					   bool addSelect = true);
+	static void populateProcessSelection(QComboBox *sel,
+					     bool addSelect = true);
+	QMetaObject::Connection PulseWidget(QWidget *widget, QColor endColor,
+					    QColor = QColor(0, 0, 0, 0),
+					    QString specifier = "QLabel ");
+
+	void listAddClicked(QListWidget *list, SwitchWidget *newWidget,
+			    QPushButton *addButton = nullptr,
+			    QMetaObject::Connection *addHighlight = nullptr);
+	bool listMoveUp(QListWidget *list);
+	bool listMoveDown(QListWidget *list);
+
+signals:
+	void SceneGroupAdded(const QString &name);
+	void SceneGroupRemoved(const QString &name);
+	void SceneGroupRenamed(const QString &oldName, const QString newName);
+
 public slots:
-	void on_switches_currentRowChanged(int idx);
-	void on_up_clicked();
-	void on_down_clicked();
-	void on_add_clicked();
-	void on_remove_clicked();
+	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();
+	void on_noMatchDelay_valueChanged(double i);
+	void on_cooldownTime_valueChanged(double i);
 	void on_startupBehavior_currentIndexChanged(int index);
+	void on_autoStartEvent_currentIndexChanged(int index);
 	void on_noMatchSwitchScene_currentTextChanged(const QString &text);
 	void on_checkInterval_valueChanged(int value);
 	void on_toggleStartButton_clicked();
 	void on_tabMoved(int from, int to);
+	void on_tabWidget_currentChanged(int index);
 
-	void on_screenRegions_currentRowChanged(int idx);
+	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 on_pauseScenes_currentRowChanged(int idx);
-	void on_pauseScenesAdd_clicked();
-	void on_pauseScenesRemove_clicked();
-
-	void on_pauseWindows_currentRowChanged(int idx);
-	void on_pauseWindowsAdd_clicked();
-	void on_pauseWindowsRemove_clicked();
+	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_sceneSequences_currentRowChanged(int idx);
 	void on_sceneSequenceAdd_clicked();
 	void on_sceneSequenceRemove_clicked();
 	void on_sceneSequenceSave_clicked();
 	void on_sceneSequenceLoad_clicked();
 	void on_sceneSequenceUp_clicked();
 	void on_sceneSequenceDown_clicked();
-	void on_sceneSequenceDelayUnits_currentIndexChanged(int index);
-
-	void on_autoStopSceneCheckBox_stateChanged(int state);
-	void on_autoStopScenes_currentTextChanged(const QString &text);
-
-	void on_autoStartSceneCheckBox_stateChanged(int state);
-	void on_autoStartType_currentIndexChanged(int index);
-	void on_autoStartScenes_currentTextChanged(const QString &text);
 
 	void on_verboseLogging_stateChanged(int state);
+	void on_uiHintsDisable_stateChanged(int state);
 
 	void on_exportSettings_clicked();
 	void on_importSettings_clicked();
 
-	void on_sceneTransitions_currentRowChanged(int idx);
 	void on_transitionsAdd_clicked();
 	void on_transitionsRemove_clicked();
-	void on_defaultTransitions_currentRowChanged(int idx);
+	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_browseButton_clicked();
 	void on_readFileCheckBox_stateChanged(int state);
-	void on_fileType_currentIndexChanged(int idx);
 	void on_readPathLineEdit_textChanged(const QString &text);
 	void on_writePathLineEdit_textChanged(const QString &text);
 	void on_browseButton_2_clicked();
@@ -146,35 +160,26 @@ public slots:
 	void on_executableDown_clicked();
 	void on_executableAdd_clicked();
 	void on_executableRemove_clicked();
-	void on_executables_currentRowChanged(int idx);
 
 	void on_idleCheckBox_stateChanged(int state);
-	void on_idleTransitions_currentTextChanged(const QString &text);
-	void on_idleScenes_currentTextChanged(const QString &text);
-	void on_idleSpinBox_valueChanged(int i);
 	void on_ignoreIdleWindows_currentRowChanged(int idx);
 	void on_ignoreIdleAdd_clicked();
 	void on_ignoreIdleRemove_clicked();
 
 	void on_randomAdd_clicked();
 	void on_randomRemove_clicked();
-	void on_randomScenesList_currentRowChanged(int idx);
 
 	void on_fileAdd_clicked();
 	void on_fileRemove_clicked();
-	void on_fileScenesList_currentRowChanged(int idx);
-	void on_browseButton_3_clicked();
+	void on_fileSwitches_currentRowChanged(int idx);
 	void on_fileUp_clicked();
 	void on_fileDown_clicked();
 
-	void on_mediaSwitches_currentRowChanged(int idx);
 	void on_mediaAdd_clicked();
 	void on_mediaRemove_clicked();
 	void on_mediaUp_clicked();
 	void on_mediaDown_clicked();
-	void on_mediaTimeRestrictions_currentIndexChanged(int idx);
 
-	void on_timeSwitches_currentRowChanged(int idx);
 	void on_timeAdd_clicked();
 	void on_timeRemove_clicked();
 	void on_timeUp_clicked();
@@ -184,8 +189,24 @@ public slots:
 	void on_audioRemove_clicked();
 	void on_audioUp_clicked();
 	void on_audioDown_clicked();
-	void on_audioSwitches_currentRowChanged(int idx);
-	void on_audioSources_currentTextChanged(const QString &text);
+	void on_audioFallback_toggled(bool on);
+
+	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();
@@ -198,41 +219,34 @@ public slots:
 private:
 };
 
-/********************************************************************************
+/******************************************************************************
  * Windowtitle helper
- ********************************************************************************/
+ ******************************************************************************/
 void GetWindowList(std::vector<std::string> &windows);
-void GetWindowList(QStringList &windows); // Overloaded
+void GetWindowList(QStringList &windows);
 void GetCurrentWindowTitle(std::string &title);
 bool isFullscreen(std::string &title);
 bool isMaximized(std::string &title);
 
-/********************************************************************************
+/******************************************************************************
  * Screenregion helper
- ********************************************************************************/
+ ******************************************************************************/
 std::pair<int, int> getCursorPos();
 
-/********************************************************************************
+/******************************************************************************
  * Idle detection helper
- ********************************************************************************/
+ ******************************************************************************/
 int secondsSinceLastInput();
 
-/********************************************************************************
+/******************************************************************************
  * Executable helper
- ********************************************************************************/
+ ******************************************************************************/
 void GetProcessList(QStringList &processes);
 bool isInFocus(const QString &executable);
 
-/********************************************************************************
+/******************************************************************************
  * Sceneswitch helper
- ********************************************************************************/
-struct obs_weak_source;
-typedef struct obs_weak_source obs_weak_source_t;
-
-typedef struct transitionData {
-	std::string name = "";
-	int duration = 0;
-} transitionData;
+ ******************************************************************************/
 
 void setNextTransition(OBSWeakSource &targetScene, obs_source_t *currentSource,
 		       OBSWeakSource &transition,
@@ -240,13 +254,11 @@ void setNextTransition(OBSWeakSource &targetScene, obs_source_t *currentSource,
 void overwriteTransitionOverride(obs_weak_source_t *sceneWs,
 				 obs_source_t *transition, transitionData &td);
 void restoreTransitionOverride(obs_source_t *scene, transitionData td);
-
 void switchScene(OBSWeakSource &scene, OBSWeakSource &transition,
-		 bool &transitionOverrideOverride,
-		 std::unique_lock<std::mutex> &lock);
+		 bool &transitionOverrideOverride);
 
-/********************************************************************************
+/******************************************************************************
  * Main SwitcherData
- ********************************************************************************/
+ ******************************************************************************/
 struct SwitcherData;
 extern SwitcherData *switcher;

src/headers/scene-group.hpp

@@ -0,0 +1,108 @@
+#pragma once
+
+#include <vector>
+#include <QDialog>
+#include <QLabel>
+#include <QLineEdit>
+#include <QComboBox>
+#include <QSpinBox>
+#include <QDoubleSpinBox>
+#include <QCheckBox>
+#include <obs.hpp>
+
+auto constexpr invalid_scene_group_name = "invalid-scene-group";
+
+enum class AdvanceCondition {
+	Count,
+	Time,
+	Random,
+};
+
+struct SceneGroup {
+	OBSWeakSource getCurrentScene();
+	OBSWeakSource getNextScene();
+	OBSWeakSource getNextSceneCount();
+	OBSWeakSource getNextSceneTime();
+	OBSWeakSource getNextSceneRandom();
+	void advanceIdx();
+
+	std::string name = invalid_scene_group_name;
+	AdvanceCondition type = AdvanceCondition::Count;
+	std::vector<OBSWeakSource> scenes = {};
+	int count = 1;
+	double time = 0;
+	bool repeat = false;
+
+	size_t currentIdx = 0;
+
+	int currentCount = -1;
+	std::chrono::high_resolution_clock::time_point lastAdvTime;
+	OBSWeakSource lastRandomScene = nullptr;
+
+	inline SceneGroup(){};
+	inline SceneGroup(std::string name_) : name(name_){};
+	inline SceneGroup(std::string name_, AdvanceCondition type_,
+			  std::vector<OBSWeakSource> scenes_, int count_,
+			  double time_, bool repeat_)
+		: name(name_),
+		  type(type_),
+		  scenes(scenes_),
+		  count(count_),
+		  time(time_),
+		  repeat(repeat_)
+	{
+	}
+};
+
+enum class SwitchTargetType {
+	Scene,
+	SceneGroup,
+};
+
+class SceneGroupEditWidget : public QWidget {
+	Q_OBJECT
+
+public:
+	SceneGroupEditWidget();
+	void SetEditSceneGroup(SceneGroup *sg);
+	void ShowCurrentTypeEdit();
+
+private slots:
+	void TypeChanged(int type);
+	void CountChanged(int count);
+	void TimeChanged(double time);
+	void RepeatChanged(int state);
+
+private:
+	QComboBox *type;
+
+	QWidget *timeEdit;
+	QWidget *countEdit;
+
+	QSpinBox *count;
+	QDoubleSpinBox *time;
+	QLabel *random;
+
+	QCheckBox *repeat;
+
+	SceneGroup *sceneGroup = nullptr;
+};
+
+// Based on OBS's NameDialog
+class SGNameDialog : public QDialog {
+	Q_OBJECT
+
+public:
+	SGNameDialog(QWidget *parent);
+
+	// Returns true if user clicks OK, false otherwise
+	// userTextInput returns string that user typed into dialog
+	static bool AskForName(QWidget *parent, const QString &title,
+			       const QString &text, std::string &userTextInput,
+			       const QString &placeHolder = QString(""),
+			       int maxSize = 170);
+
+private:
+	QLabel *label;
+	QLineEdit *userText;
+};

src/headers/scene-trigger.hpp

@@ -0,0 +1,68 @@
+#pragma once
+
+#include "switch-generic.hpp"
+
+enum class sceneTriggerType {
+	NONE = 0,
+	SCENE_ACTIVE = 1,
+	SCENE_INACTIVE = 2,
+	SCENE_LEAVE = 3,
+};
+
+enum class sceneTriggerAction {
+	NONE = 0,
+	START_RECORDING,
+	PAUSE_RECORDING,
+	UNPAUSE_RECORDING,
+	STOP_RECORDING,
+
+	START_STREAMING,
+	STOP_STREAMING,
+
+	START_REPLAY_BUFFER,
+	STOP_REPLAY_BUFFER,
+
+	MUTE_SOURCE,
+};
+
+struct SceneTrigger : SceneSwitcherEntry {
+	static bool pause;
+	sceneTriggerType triggerType = sceneTriggerType::NONE;
+	sceneTriggerAction triggerAction = sceneTriggerAction::NONE;
+	double duration = 0;
+	OBSWeakSource audioSource = nullptr;
+
+	const char *getType() { return "trigger"; }
+	void save(obs_data_t *obj);
+	void load(obs_data_t *obj);
+
+	bool checkMatch(OBSWeakSource previousScene);
+	void performAction();
+	void logMatch();
+};
+
+class SceneTriggerWidget : public SwitchWidget {
+	Q_OBJECT
+
+public:
+	SceneTriggerWidget(QWidget *parent, SceneTrigger *s);
+	SceneTrigger *getSwitchData();
+	void setSwitchData(SceneTrigger *s);
+
+	static void swapSwitchData(SceneTriggerWidget *s1,
+				   SceneTriggerWidget *s2);
+
+private slots:
+	void TriggerTypeChanged(int index);
+	void TriggerActionChanged(int index);
+	void DurationChanged(double dur);
+	void AudioSourceChanged(const QString &text);
+
+private:
+	QComboBox *triggers;
+	QComboBox *actions;
+	QDoubleSpinBox *duration;
+	QComboBox *audioSources;
+
+	SceneTrigger *switchData;
+};

src/headers/switch-audio.hpp

@@ -1,115 +1,96 @@
 #pragma once
-#include <string>
-#include "utility.hpp"
+#include <QSpinBox>
+
 #include "switch-generic.hpp"
+#include "volume-control.hpp"
 
 constexpr auto audio_func = 8;
 constexpr auto default_priority_8 = audio_func;
 
+typedef enum {
+	ABOVE,
+	BELOW,
+} audioCondition;
+
 struct AudioSwitch : virtual SceneSwitcherEntry {
-	OBSWeakSource audioSource;
-	int volumeThreshold;
-	float peak;
-	std::string audioSwitchStr;
-	obs_volmeter_t *volmeter;
+	static bool pause;
+	OBSWeakSource audioSource = nullptr;
+	int volumeThreshold = 0;
+	audioCondition condition = ABOVE;
+	double duration = 0;
+	unsigned int matchCount = 0;
+	float peak = -1;
+	obs_volmeter_t *volmeter = nullptr;
 
 	const char *getType() { return "audio"; }
-
+	bool initialized();
+	bool valid();
+	void save(obs_data_t *obj);
+	void load(obs_data_t *obj);
 	static void setVolumeLevel(void *data,
 				   const float magnitude[MAX_AUDIO_CHANNELS],
 				   const float peak[MAX_AUDIO_CHANNELS],
-				   const float inputPeak[MAX_AUDIO_CHANNELS])
-	{
-		UNUSED_PARAMETER(magnitude);
-		UNUSED_PARAMETER(inputPeak);
-		AudioSwitch *s = static_cast<AudioSwitch *>(data);
+				   const float inputPeak[MAX_AUDIO_CHANNELS]);
+	void resetVolmeter();
 
-		s->peak = peak[0];
-		for (int i = 1; i < MAX_AUDIO_CHANNELS; i++)
-			if (peak[i] > s->peak)
-				s->peak = peak[i];
-	}
-
-	bool valid()
-	{
-		return (usePreviousScene || WeakSourceValid(scene)) &&
-		       WeakSourceValid(audioSource) &&
-		       WeakSourceValid(transition);
-	}
-
-	inline AudioSwitch(OBSWeakSource scene_, OBSWeakSource transition_,
-			   OBSWeakSource audioSource_, int volumeThreshold_,
-			   bool usePreviousScene_, std::string audioSwitchStr_)
-		: SceneSwitcherEntry(scene_, transition_, usePreviousScene_),
-		  audioSource(audioSource_),
-		  volumeThreshold(volumeThreshold_),
-		  audioSwitchStr(audioSwitchStr_)
-	{
-		volmeter = obs_volmeter_create(OBS_FADER_LOG);
-		obs_volmeter_add_callback(volmeter, setVolumeLevel, this);
-		obs_source_t *as = obs_weak_source_get_source(audioSource);
-		if (!obs_volmeter_attach_source(volmeter, as)) {
-			const char *name = obs_source_get_name(as);
-			blog(LOG_WARNING,
-			     "failed to attach volmeter to source %s", name);
-		}
-		obs_source_release(as);
-	}
-
-	AudioSwitch(const AudioSwitch &other)
-		: SceneSwitcherEntry(other.scene, other.transition,
-				     other.usePreviousScene),
-		  audioSource(other.audioSource),
-		  volumeThreshold(other.volumeThreshold),
-		  audioSwitchStr(other.audioSwitchStr)
-	{
-		volmeter = obs_volmeter_create(OBS_FADER_LOG);
-		obs_volmeter_add_callback(volmeter, setVolumeLevel, this);
-		obs_source_t *as =
-			obs_weak_source_get_source(other.audioSource);
-		if (!obs_volmeter_attach_source(volmeter, as)) {
-			const char *name = obs_source_get_name(as);
-			blog(LOG_WARNING,
-			     "failed to attach volmeter to source %s", name);
-		}
-		obs_source_release(as);
-	}
-
-	AudioSwitch(AudioSwitch &&other)
-		: SceneSwitcherEntry(other.scene, other.transition,
-				     other.usePreviousScene),
-		  audioSource(other.audioSource),
-		  volumeThreshold(other.volumeThreshold),
-		  audioSwitchStr(other.audioSwitchStr),
-		  volmeter(other.volmeter)
-	{
-		other.volmeter = nullptr;
-	}
-
-	inline ~AudioSwitch()
-	{
-		obs_volmeter_remove_callback(volmeter, setVolumeLevel, this);
-		obs_volmeter_destroy(volmeter);
-	}
-
-	AudioSwitch &operator=(const AudioSwitch &other)
-	{
-		return *this = AudioSwitch(other);
-	}
-
-	AudioSwitch &operator=(AudioSwitch &&other) noexcept
-	{
-		if (this == &other) {
-			return *this;
-		}
-		obs_volmeter_destroy(volmeter);
-		volmeter = other.volmeter;
-		other.volmeter = nullptr;
-		return *this;
-	}
+	AudioSwitch(){};
+	AudioSwitch(const AudioSwitch &other);
+	AudioSwitch(AudioSwitch &&other);
+	~AudioSwitch();
+	AudioSwitch &operator=(const AudioSwitch &other);
+	AudioSwitch &operator=(AudioSwitch &&other) noexcept;
+	friend void swap(AudioSwitch &first, AudioSwitch &second);
 };
 
-static inline QString MakeAudioSwitchName(const QString &scene,
-					  const QString &transition,
-					  const QString &audioSrouce,
-					  const int &volume);
+struct AudioSwitchFallback : virtual SceneSwitcherEntry {
+	const char *getType() { return "audio_fallback"; }
+	void save(obs_data_t *obj);
+	void load(obs_data_t *obj);
+
+	bool enable = false;
+	double duration = 0;
+	unsigned int matchCount = 0;
+};
+
+class AudioSwitchWidget : public SwitchWidget {
+	Q_OBJECT
+
+public:
+	AudioSwitchWidget(QWidget *parent, AudioSwitch *s);
+	void UpdateVolmeterSource();
+	AudioSwitch *getSwitchData();
+	void setSwitchData(AudioSwitch *s);
+
+	static void swapSwitchData(AudioSwitchWidget *as1,
+				   AudioSwitchWidget *as2);
+
+private slots:
+	void SourceChanged(const QString &text);
+	void VolumeThresholdChanged(int vol);
+	void ConditionChanged(int cond);
+	void DurationChanged(double dur);
+
+private:
+	QComboBox *audioSources;
+	QComboBox *condition;
+	QSpinBox *audioVolumeThreshold;
+	QDoubleSpinBox *duration;
+	VolControl *volMeter;
+
+	AudioSwitch *switchData;
+};
+
+class AudioSwitchFallbackWidget : public SwitchWidget {
+	Q_OBJECT
+
+public:
+	AudioSwitchFallbackWidget(QWidget *parent, AudioSwitchFallback *s);
+
+private slots:
+	void DurationChanged(double dur);
+
+private:
+	QDoubleSpinBox *duration;
+
+	AudioSwitchFallback *switchData;
+};

src/headers/switch-executable.hpp

@@ -1,28 +1,38 @@
 #pragma once
-#include <string>
-#include "utility.hpp"
+#include <QCheckBox>
 #include "switch-generic.hpp"
 
 constexpr auto exe_func = 3;
 constexpr auto default_priority_3 = exe_func;
 
-struct ExecutableSceneSwitch : SceneSwitcherEntry {
-	QString exe;
-	bool inFocus;
+struct ExecutableSwitch : SceneSwitcherEntry {
+	static bool pause;
+	QString exe = "";
+	bool inFocus = false;
 
 	const char *getType() { return "exec"; }
-
-	inline ExecutableSceneSwitch(OBSWeakSource scene_,
-				     OBSWeakSource transition_,
-				     const QString &exe_, bool inFocus_)
-		: SceneSwitcherEntry(scene_, transition_),
-		  exe(exe_),
-		  inFocus(inFocus_)
-	{
-	}
+	void save(obs_data_t *obj);
+	void load(obs_data_t *obj);
 };
 
-static inline QString MakeSwitchNameExecutable(const QString &scene,
-					       const QString &value,
-					       const QString &transition,
-					       bool inFocus);
+class ExecutableSwitchWidget : public SwitchWidget {
+	Q_OBJECT
+
+public:
+	ExecutableSwitchWidget(QWidget *parent, ExecutableSwitch *s);
+	ExecutableSwitch *getSwitchData();
+	void setSwitchData(ExecutableSwitch *s);
+
+	static void swapSwitchData(ExecutableSwitchWidget *s1,
+				   ExecutableSwitchWidget *s2);
+
+private slots:
+	void ProcessChanged(const QString &text);
+	void FocusChanged(int state);
+
+private:
+	QComboBox *processes;
+	QCheckBox *requiresFocus;
+
+	ExecutableSwitch *switchData;
+};

src/headers/switch-file.hpp

@@ -1,33 +1,62 @@
 #pragma once
-#include <string>
-#include "utility.hpp"
 #include "switch-generic.hpp"
+#include <QPlainTextEdit>
+#include <obs-module.h>
 
 constexpr auto read_file_func = 0;
 constexpr auto default_priority_0 = read_file_func;
 
+typedef enum {
+	LOCAL,
+	REMOTE,
+} file_type;
+
 struct FileSwitch : SceneSwitcherEntry {
-	std::string file;
-	std::string text;
+	static bool pause;
+	std::string file = obs_module_text("AdvSceneSwitcher.enterPath");
+	std::string text = obs_module_text("AdvSceneSwitcher.enterText");
 	bool remote = false;
 	bool useRegex = false;
 	bool useTime = false;
+	bool onlyMatchIfChanged = false;
 	QDateTime lastMod;
+	size_t lastHash = 0;
 
 	const char *getType() { return "file"; }
+	void save(obs_data_t *obj);
+	void load(obs_data_t *obj);
+};
 
-	inline FileSwitch(OBSWeakSource scene_, OBSWeakSource transition_,
-			  const char *file_, const char *text_, bool remote_,
-			  bool useRegex_, bool useTime_)
-		: SceneSwitcherEntry(scene_, transition_),
-		  file(file_),
-		  text(text_),
-		  remote(remote_),
-		  useRegex(useRegex_),
-		  useTime(useTime_),
-		  lastMod()
-	{
-	}
+class FileSwitchWidget : public SwitchWidget {
+	Q_OBJECT
+
+public:
+	FileSwitchWidget(QWidget *parent, FileSwitch *s);
+	FileSwitch *getSwitchData();
+	void setSwitchData(FileSwitch *s);
+
+	static void swapSwitchData(FileSwitchWidget *as1,
+				   FileSwitchWidget *as2);
+
+private slots:
+	void FileTypeChanged(int index);
+	void FilePathChanged();
+	void MatchTextChanged();
+	void UseRegexChanged(int state);
+	void CheckModificationDateChanged(int state);
+	void CheckFileContentChanged(int state);
+	void BrowseButtonClicked();
+
+private:
+	QComboBox *fileType;
+	QLineEdit *filePath;
+	QPushButton *browseButton;
+	QPlainTextEdit *matchText;
+	QCheckBox *useRegex;
+	QCheckBox *checkModificationDate;
+	QCheckBox *checkFileContent;
+
+	FileSwitch *switchData;
 };
 
 struct FileIOData {
@@ -41,4 +70,4 @@ static inline QString MakeFileSwitchName(const QString &scene,
 					 const QString &transition,
 					 const QString &fileName,
 					 const QString &text, bool useRegex,
-					 bool useTime);
+					 bool useTime, bool onlyMatchIfChanged);

src/headers/switch-generic.hpp

@@ -1,48 +1,88 @@
 #pragma once
-#include <string>
 #include <obs.hpp>
+#include <QComboBox>
 
 struct SceneSwitcherEntry {
-	OBSWeakSource scene;
-	OBSWeakSource transition;
-	bool usePreviousScene;
-
-	virtual bool valid()
-	{
-		return (usePreviousScene || WeakSourceValid(scene)) &&
-		       WeakSourceValid(transition);
-	}
+	SwitchTargetType targetType = SwitchTargetType::Scene;
+	SceneGroup *group = nullptr;
+	OBSWeakSource scene = nullptr;
+	OBSWeakSource transition = nullptr;
+	bool usePreviousScene = false;
 
 	virtual const char *getType() = 0;
+	virtual bool initialized();
+	virtual bool valid();
+	virtual void logMatchScene();
+	virtual void logMatchSceneGroup();
+	virtual void logMatch();
+	virtual OBSWeakSource getScene();
+	virtual void save(obs_data_t *obj,
+			  const char *targetTypeSaveName = "targetType",
+			  const char *targetSaveName = "target",
+			  const char *transitionSaveName = "transition");
+	virtual void load(obs_data_t *obj,
+			  const char *targetTypeLoadName = "targetType",
+			  const char *targetLoadName = "target",
+			  const char *transitionLoadName = "transition");
 
-	// TODO
-	//virtual bool checkMatch() = 0;
-
-	virtual void logMatch()
-	{
-		obs_source_t *s = obs_weak_source_get_source(scene);
-		const char *sceneName = obs_source_get_name(s);
-		obs_source_release(s);
-		blog(LOG_INFO,
-		     "Advanced Scene Switcher match for '%s' - switch to scene '%s'",
-		     getType(), sceneName);
-	}
-
-	inline SceneSwitcherEntry() : usePreviousScene(false) {}
+	inline SceneSwitcherEntry() {}
 
 	inline SceneSwitcherEntry(OBSWeakSource scene_,
 				  OBSWeakSource transition_,
-				  bool usePreviousScene_)
+				  bool usePreviousScene_ = false)
 		: scene(scene_),
 		  transition(transition_),
 		  usePreviousScene(usePreviousScene_)
 	{
 	}
-	inline SceneSwitcherEntry(OBSWeakSource scene_,
-				  OBSWeakSource transition_)
-		: scene(scene_),
+
+	inline SceneSwitcherEntry(SceneGroup *group_, OBSWeakSource transition_,
+				  bool usePreviousScene_ = false)
+		: group(group_),
 		  transition(transition_),
-		  usePreviousScene(false)
+		  usePreviousScene(usePreviousScene_)
 	{
 	}
+
+	inline SceneSwitcherEntry(SwitchTargetType targetType_,
+				  SceneGroup *group_, OBSWeakSource scene_,
+				  OBSWeakSource transition_,
+				  bool usePreviousScene_ = false)
+		: targetType(targetType_),
+		  group(group_),
+		  scene(scene_),
+		  transition(transition_),
+		  usePreviousScene(usePreviousScene_)
+	{
+	}
+
+	virtual ~SceneSwitcherEntry() {}
+};
+
+class SwitchWidget : public QWidget {
+	Q_OBJECT
+
+public:
+	SwitchWidget(QWidget *parent, SceneSwitcherEntry *s,
+		     bool usePreviousScene = true, bool addSceneGroup = false);
+	virtual SceneSwitcherEntry *getSwitchData();
+	virtual void setSwitchData(SceneSwitcherEntry *s);
+	void showSwitchData();
+
+	static void swapSwitchData(SwitchWidget *s1, SwitchWidget *s2);
+
+private slots:
+	void SceneChanged(const QString &text);
+	void TransitionChanged(const QString &text);
+	void SceneGroupAdd(const QString &name);
+	void SceneGroupRemove(const QString &name);
+	void SceneGroupRename(const QString &oldName, const QString &newName);
+
+protected:
+	bool loading = true;
+
+	QComboBox *scenes;
+	QComboBox *transitions;
+
+	SceneSwitcherEntry *switchData;
 };

src/headers/switch-idle.hpp

@@ -1,6 +1,4 @@
 #pragma once
-#include <string>
-#include "utility.hpp"
 #include "switch-generic.hpp"
 
 constexpr auto default_idle_time = 60;
@@ -8,9 +6,27 @@ constexpr auto idle_func = 2;
 constexpr auto default_priority_2 = idle_func;
 
 struct IdleData : SceneSwitcherEntry {
+	static bool pause;
 	bool idleEnable = false;
 	int time = default_idle_time;
 	bool alreadySwitched = false;
 
 	const char *getType() { return "idle"; }
+	void save(obs_data_t *obj);
+	void load(obs_data_t *obj);
+};
+
+class IdleWidget : public SwitchWidget {
+	Q_OBJECT
+
+public:
+	IdleWidget(QWidget *parent, IdleData *s);
+
+private slots:
+	void DurationChanged(int dur);
+
+private:
+	QSpinBox *duration;
+
+	IdleData *switchData;
 };

src/headers/switch-media.hpp

@@ -1,6 +1,4 @@
 #pragma once
-#include <string>
-#include "utility.hpp"
 #include "switch-generic.hpp"
 
 constexpr auto media_func = 6;
@@ -15,36 +13,67 @@ typedef enum {
 } time_restriction;
 
 struct MediaSwitch : SceneSwitcherEntry {
-	OBSWeakSource source;
-	obs_media_state state;
-	time_restriction restriction;
-	int64_t time;
-	bool matched;
-	std::string mediaSwitchStr;
+	static bool pause;
+	OBSWeakSource source = nullptr;
+	obs_media_state state = OBS_MEDIA_STATE_NONE;
+	bool anyState = false;
+	time_restriction restriction = TIME_RESTRICTION_NONE;
+	int64_t time = 0;
 
-	const char *getType() { return "meida"; }
+	// Trigger scene change only once even if media state might trigger repeatedly
+	bool matched = false;
 
-	bool valid()
-	{
-		return (usePreviousScene || WeakSourceValid(scene)) &&
-		       WeakSourceValid(source) && WeakSourceValid(transition);
-	}
+	std::atomic_bool stopped = {false};
+	std::atomic_bool ended = {false};
 
-	inline MediaSwitch(OBSWeakSource scene_, OBSWeakSource source_,
-			   OBSWeakSource transition_, obs_media_state state_,
-			   time_restriction restriction_, uint64_t time_,
-			   bool usePreviousScene_, std::string mediaSwitchStr_)
-		: SceneSwitcherEntry(scene_, transition_, usePreviousScene_),
-		  source(source_),
-		  state(state_),
-		  restriction(restriction_),
-		  time(time_),
-		  mediaSwitchStr(mediaSwitchStr_)
-	{
-	}
+	// Workaround to enable use of "ended" to specify end of VLC playlist
+	bool previousStateEnded = false;
+
+	bool playedToEnd = false;
+
+	const char *getType() { return "media"; }
+	bool initialized();
+	bool valid();
+	void save(obs_data_t *obj);
+	void load(obs_data_t *obj);
+
+	void clearSignalHandler();
+	void resetSignalHandler();
+	static void MediaStopped(void *data, calldata_t *);
+	static void MediaEnded(void *data, calldata_t *);
+
+	inline MediaSwitch(){};
+
+	MediaSwitch(const MediaSwitch &other);
+	MediaSwitch(MediaSwitch &&other);
+	~MediaSwitch();
+	MediaSwitch &operator=(const MediaSwitch &other);
+	MediaSwitch &operator=(MediaSwitch &&other) noexcept;
+	friend void swap(MediaSwitch &first, MediaSwitch &second);
 };
 
-static inline QString
-MakeMediaSwitchName(const QString &source, const QString &scene,
-		    const QString &transition, obs_media_state state,
-		    time_restriction restriction, uint64_t time);
+class MediaSwitchWidget : public SwitchWidget {
+	Q_OBJECT
+
+public:
+	MediaSwitchWidget(QWidget *parent, MediaSwitch *s);
+	MediaSwitch *getSwitchData();
+	void setSwitchData(MediaSwitch *s);
+
+	static void swapSwitchData(MediaSwitchWidget *s1,
+				   MediaSwitchWidget *s2);
+
+private slots:
+	void SourceChanged(const QString &text);
+	void StateChanged(int index);
+	void TimeRestrictionChanged(int index);
+	void TimeChanged(int time);
+
+private:
+	QComboBox *mediaSources;
+	QComboBox *states;
+	QComboBox *timeRestrictions;
+	QSpinBox *time;
+
+	MediaSwitch *switchData;
+};

src/headers/switch-pause.hpp

@@ -0,0 +1,64 @@
+#pragma once
+#include "switch-generic.hpp"
+
+enum class PauseType {
+	Scene,
+	Window,
+};
+
+enum class PauseTarget {
+	All,
+	Transition,
+	Window,
+	Executable,
+	Region,
+	Media,
+	File,
+	Random,
+	Time,
+	Idle,
+	Sequence,
+	Audio,
+};
+
+struct PauseEntry : SceneSwitcherEntry {
+	PauseType pauseType = PauseType::Scene;
+	PauseTarget pauseTarget = PauseTarget::All;
+	std::string window = "";
+
+	const char *getType() { return "pause"; }
+	bool valid();
+
+	inline PauseEntry(){};
+	inline PauseEntry(OBSWeakSource scene_, PauseType pauseType_,
+			  PauseTarget pauseTarget_, const std::string &window_)
+		: SceneSwitcherEntry(scene_, nullptr),
+		  pauseType(pauseType_),
+		  pauseTarget(pauseTarget_),
+		  window(window_)
+	{
+	}
+};
+
+class PauseEntryWidget : public SwitchWidget {
+	Q_OBJECT
+
+public:
+	PauseEntryWidget(QWidget *parent, PauseEntry *s);
+	PauseEntry *getSwitchData();
+	void setSwitchData(PauseEntry *s);
+
+	static void swapSwitchData(PauseEntryWidget *s1, PauseEntryWidget *s2);
+
+private slots:
+	void PauseTypeChanged(int index);
+	void PauseTargetChanged(int index);
+	void WindowChanged(const QString &text);
+
+private:
+	QComboBox *pauseTypes;
+	QComboBox *pauseTargets;
+	QComboBox *windows;
+
+	PauseEntry *switchData;
+};

src/headers/switch-random.hpp

@@ -1,23 +1,31 @@
 #pragma once
-#include <string>
-#include "utility.hpp"
 #include "switch-generic.hpp"
 
 struct RandomSwitch : SceneSwitcherEntry {
-	double delay;
-	std::string randomSwitchStr;
+	static bool pause;
+	double delay = 0.0;
 
 	const char *getType() { return "random"; }
-
-	inline RandomSwitch(OBSWeakSource scene_, OBSWeakSource transition_,
-			    double delay_, std::string str)
-		: SceneSwitcherEntry(scene_, transition_),
-		  delay(delay_),
-		  randomSwitchStr(str)
-	{
-	}
+	void save(obs_data_t *obj);
+	void load(obs_data_t *obj);
 };
 
-static inline QString MakeRandomSwitchName(const QString &scene,
-					   const QString &transition,
-					   double &delay);
+class RandomSwitchWidget : public SwitchWidget {
+	Q_OBJECT
+
+public:
+	RandomSwitchWidget(QWidget *parent, RandomSwitch *s);
+	RandomSwitch *getSwitchData();
+	void setSwitchData(RandomSwitch *s);
+
+	static void swapSwitchData(RandomSwitchWidget *s1,
+				   RandomSwitchWidget *s2);
+
+private slots:
+	void DelayChanged(double d);
+
+private:
+	QDoubleSpinBox *delay;
+
+	RandomSwitch *switchData;
+};

src/headers/switch-screen-region.hpp

@@ -1,32 +1,51 @@
 #pragma once
-#include <string>
-#include "utility.hpp"
+#include <QSpinBox>
 #include "switch-generic.hpp"
 
 constexpr auto screen_region_func = 4;
 constexpr auto default_priority_4 = screen_region_func;
 
 struct ScreenRegionSwitch : SceneSwitcherEntry {
-	int minX, minY, maxX, maxY;
-	std::string regionStr;
+	static bool pause;
+	OBSWeakSource excludeScene = nullptr;
+	int minX = 0, minY = 0, maxX = 0, maxY = 0;
 
 	const char *getType() { return "region"; }
-
-	inline ScreenRegionSwitch(OBSWeakSource scene_,
-				  OBSWeakSource transition_, int minX_,
-				  int minY_, int maxX_, int maxY_,
-				  std::string regionStr_)
-		: SceneSwitcherEntry(scene_, transition_),
-		  minX(minX_),
-		  minY(minY_),
-		  maxX(maxX_),
-		  maxY(maxY_),
-		  regionStr(regionStr_)
-	{
-	}
+	void save(obs_data_t *obj);
+	void load(obs_data_t *obj);
 };
 
-static inline QString MakeScreenRegionSwitchName(const QString &scene,
-						 const QString &transition,
-						 int minX, int minY, int maxX,
-						 int maxY);
+class ScreenRegionWidget : public SwitchWidget {
+	Q_OBJECT
+
+public:
+	ScreenRegionWidget(QWidget *parent, ScreenRegionSwitch *s);
+	ScreenRegionSwitch *getSwitchData();
+	void setSwitchData(ScreenRegionSwitch *s);
+
+	static void swapSwitchData(ScreenRegionWidget *s1,
+				   ScreenRegionWidget *s2);
+
+	void showFrame();
+	void hideFrame();
+
+private slots:
+	void ExcludeSceneChanged(const QString &text);
+	void MinXChanged(int pos);
+	void MinYChanged(int pos);
+	void MaxXChanged(int pos);
+	void MaxYChanged(int pos);
+
+private:
+	QComboBox *excludeScenes;
+	QSpinBox *minX;
+	QSpinBox *minY;
+	QSpinBox *maxX;
+	QSpinBox *maxY;
+
+	QFrame helperFrame;
+
+	ScreenRegionSwitch *switchData;
+
+	void drawFrame();
+};

src/headers/switch-sequence.hpp

@@ -0,0 +1,53 @@
+#pragma once
+#include "switch-generic.hpp"
+
+constexpr auto round_trip_func = 1;
+constexpr auto default_priority_1 = round_trip_func;
+
+typedef enum {
+	SECONDS,
+	MINUTES,
+	HOURS,
+} delay_units;
+
+struct SceneSequenceSwitch : SceneSwitcherEntry {
+	static bool pause;
+	OBSWeakSource startScene = nullptr;
+	double delay = 0;
+	int delayMultiplier = 1;
+	bool interruptible = false;
+	unsigned int matchCount = 0;
+
+	const char *getType() { return "sequence"; }
+	bool initialized();
+	bool valid();
+	void save(obs_data_t *obj);
+	void load(obs_data_t *obj);
+};
+
+class SequenceWidget : public SwitchWidget {
+	Q_OBJECT
+
+public:
+	SequenceWidget(QWidget *parent, SceneSequenceSwitch *s);
+	SceneSequenceSwitch *getSwitchData();
+	void setSwitchData(SceneSequenceSwitch *s);
+
+	static void swapSwitchData(SequenceWidget *s1, SequenceWidget *s2);
+
+	void UpdateDelay();
+
+private slots:
+	void DelayChanged(double delay);
+	void DelayUnitsChanged(int idx);
+	void StartSceneChanged(const QString &text);
+	void InterruptibleChanged(int state);
+
+private:
+	QDoubleSpinBox *delay;
+	QComboBox *delayUnits;
+	QComboBox *startScenes;
+	QCheckBox *interruptible;
+
+	SceneSequenceSwitch *switchData;
+};

src/headers/switch-time.hpp

@@ -1,7 +1,6 @@
 #pragma once
-#include <string>
-#include <QDateTime>
-#include "utility.hpp"
+#include <QTimeEdit>
+
 #include "switch-generic.hpp"
 
 constexpr auto time_func = 7;
@@ -20,24 +19,32 @@ typedef enum {
 } timeTrigger;
 
 struct TimeSwitch : SceneSwitcherEntry {
-	timeTrigger trigger;
-	QTime time;
-	std::string timeSwitchStr;
+	static bool pause;
+	timeTrigger trigger = ANY_DAY;
+	QTime time = QTime(0, 0);
 
 	const char *getType() { return "time"; }
-
-	inline TimeSwitch(OBSWeakSource scene_, OBSWeakSource transition_,
-			  timeTrigger trigger_, QTime time_,
-			  bool usePreviousScene_, std::string timeSwitchStr_)
-		: SceneSwitcherEntry(scene_, transition_, usePreviousScene_),
-		  trigger(trigger_),
-		  time(time_),
-		  timeSwitchStr(timeSwitchStr_)
-	{
-	}
+	void save(obs_data_t *obj);
+	void load(obs_data_t *obj);
 };
 
-static inline QString MakeTimeSwitchName(const QString &scene,
-					 const QString &transition,
-					 const timeTrigger &trigger,
-					 const QTime &time);
+class TimeSwitchWidget : public SwitchWidget {
+	Q_OBJECT
+
+public:
+	TimeSwitchWidget(QWidget *parent, TimeSwitch *s);
+	TimeSwitch *getSwitchData();
+	void setSwitchData(TimeSwitch *s);
+
+	static void swapSwitchData(TimeSwitchWidget *s1, TimeSwitchWidget *s2);
+
+private slots:
+	void TriggerChanged(int index);
+	void TimeChanged(const QTime &time);
+
+private:
+	QComboBox *triggers;
+	QTimeEdit *time;
+
+	TimeSwitch *switchData;
+};

src/headers/switch-transitions.hpp

@@ -1,47 +1,65 @@
 #pragma once
-#include <string>
-#include "utility.hpp"
 #include "switch-generic.hpp"
 
 struct SceneTransition : SceneSwitcherEntry {
-	OBSWeakSource scene2;
-	std::string sceneTransitionStr;
+	OBSWeakSource scene2 = nullptr;
 
 	const char *getType() { return "transition"; }
+	bool initialized();
+	bool valid();
 
-	bool valid()
-	{
-		return (WeakSourceValid(scene) && WeakSourceValid(scene2)) &&
-		       WeakSourceValid(transition);
-	}
-
+	inline SceneTransition(){};
 	inline SceneTransition(OBSWeakSource scene_, OBSWeakSource scene2_,
-			       OBSWeakSource transition_,
-			       std::string sceneTransitionStr_)
-		: SceneSwitcherEntry(scene_, transition_),
-		  scene2(scene2_),
-		  sceneTransitionStr(sceneTransitionStr_)
+			       OBSWeakSource transition_)
+		: SceneSwitcherEntry(scene_, transition_), scene2(scene2_)
 	{
 	}
 };
 
-static inline QString MakeSceneTransitionName(const QString &scene1,
-					      const QString &scene2,
-					      const QString &transition);
-
 struct DefaultSceneTransition : SceneSwitcherEntry {
-	std::string sceneTransitionStr;
+	static bool pause;
 
 	const char *getType() { return "def_transition"; }
 
+	inline DefaultSceneTransition(){};
 	inline DefaultSceneTransition(OBSWeakSource scene_,
-				      OBSWeakSource transition_,
-				      std::string sceneTransitionStr_)
-		: SceneSwitcherEntry(scene_, transition_),
-		  sceneTransitionStr(sceneTransitionStr_)
+				      OBSWeakSource transition_)
+		: SceneSwitcherEntry(scene_, transition_)
 	{
 	}
 };
 
-static inline QString MakeDefaultSceneTransitionName(const QString &scene,
-						     const QString &transition);
+class TransitionSwitchWidget : public SwitchWidget {
+	Q_OBJECT
+
+public:
+	TransitionSwitchWidget(QWidget *parent, SceneTransition *s);
+	SceneTransition *getSwitchData();
+	void setSwitchData(SceneTransition *s);
+
+	static void swapSwitchData(TransitionSwitchWidget *s1,
+				   TransitionSwitchWidget *s2);
+
+private slots:
+	void Scene2Changed(const QString &text);
+
+private:
+	QComboBox *scenes2;
+
+	SceneTransition *switchData;
+};
+
+class DefTransitionSwitchWidget : public SwitchWidget {
+	Q_OBJECT
+
+public:
+	DefTransitionSwitchWidget(QWidget *parent, DefaultSceneTransition *s);
+	DefaultSceneTransition *getSwitchData();
+	void setSwitchData(DefaultSceneTransition *s);
+
+	static void swapSwitchData(DefTransitionSwitchWidget *s1,
+				   DefTransitionSwitchWidget *s2);
+
+private:
+	DefaultSceneTransition *switchData;
+};

src/headers/switch-window.hpp

@@ -1,33 +1,43 @@
 #pragma once
-#include <string>
-#include "utility.hpp"
 #include "switch-generic.hpp"
 
 constexpr auto window_title_func = 5;
 constexpr auto default_priority_5 = window_title_func;
 
-struct WindowSceneSwitch : SceneSwitcherEntry {
-	std::string window;
-	bool fullscreen;
-	bool maximized;
-	bool focus;
+struct WindowSwitch : SceneSwitcherEntry {
+	static bool pause;
+	std::string window = "";
+	bool fullscreen = false;
+	bool maximized = false;
+	bool focus = true;
 
 	const char *getType() { return "window"; }
-
-	inline WindowSceneSwitch(OBSWeakSource scene_, const char *window_,
-				 OBSWeakSource transition_, bool fullscreen_,
-				 bool maximized_, bool focus_)
-		: SceneSwitcherEntry(scene_, transition_),
-		  window(window_),
-		  fullscreen(fullscreen_),
-		  maximized(maximized_),
-		  focus(focus_)
-	{
-	}
+	void save(obs_data_t *obj);
+	void load(obs_data_t *obj);
 };
 
-static inline QString MakeWindowSwitchName(const QString &scene,
-					   const QString &value,
-					   const QString &transition,
-					   bool fullscreen, bool maximized,
-					   bool focus);
+class WindowSwitchWidget : public SwitchWidget {
+	Q_OBJECT
+
+public:
+	WindowSwitchWidget(QWidget *parent, WindowSwitch *s);
+	WindowSwitch *getSwitchData();
+	void setSwitchData(WindowSwitch *s);
+
+	static void swapSwitchData(WindowSwitchWidget *s1,
+				   WindowSwitchWidget *s2);
+
+private slots:
+	void WindowChanged(const QString &text);
+	void FullscreenChanged(int state);
+	void MaximizedChanged(int state);
+	void FocusChanged(int state);
+
+private:
+	QComboBox *windows;
+	QCheckBox *fullscreen;
+	QCheckBox *maximized;
+	QCheckBox *focused;
+
+	WindowSwitch *switchData;
+};

src/headers/switcher-data-structs.hpp

@@ -1,34 +1,45 @@
 #pragma once
 #include <condition_variable>
-#include <string>
 #include <vector>
+#include <deque>
 #include <mutex>
 #include <QDateTime>
 #include <QThread>
 #include <curl/curl.h>
 
+#include "scene-group.hpp"
+#include "scene-trigger.hpp"
 #include "switch-audio.hpp"
 #include "switch-executable.hpp"
 #include "switch-file.hpp"
 #include "switch-idle.hpp"
 #include "switch-media.hpp"
+#include "switch-pause.hpp"
 #include "switch-random.hpp"
 #include "switch-screen-region.hpp"
 #include "switch-time.hpp"
 #include "switch-transitions.hpp"
 #include "switch-window.hpp"
-#include "swtich-sequence.hpp"
+#include "switch-sequence.hpp"
 
 constexpr auto default_interval = 300;
 constexpr auto previous_scene_name = "Previous Scene";
 
 typedef enum { NO_SWITCH = 0, SWITCH = 1, RANDOM_SWITCH = 2 } NoMatch;
 typedef enum { PERSIST = 0, START = 1, STOP = 2 } StartupBehavior;
-typedef enum {
-	RECORDING = 0,
-	STREAMING = 1,
-	RECORINDGSTREAMING = 2
-} AutoStartType;
+
+enum class AutoStartEvent {
+	NEVER,
+	RECORDING,
+	STREAMING,
+	RECORINDG_OR_STREAMING,
+};
+
+typedef struct transitionData {
+	std::string name = "";
+	int duration = 0;
+
+} transitionData;
 
 class SwitcherThread;
 
@@ -45,59 +56,63 @@ struct SwitcherData {
 	std::condition_variable transitionCv;
 	bool stop = false;
 	bool verbose = false;
+	bool disableHints = false;
+	bool showFrame = false;
 	bool tansitionOverrideOverride = false;
 
 	int interval = default_interval;
 
-	obs_source_t *waitScene = NULL;
-	OBSWeakSource previousScene = NULL;
-	OBSWeakSource PreviousScene2 = NULL;
+	obs_source_t *waitScene = nullptr;
+	OBSWeakSource previousScene = nullptr;
+	OBSWeakSource previousSceneHelper = nullptr;
 	OBSWeakSource lastRandomScene;
 	OBSWeakSource nonMatchingScene;
 	NoMatch switchIfNotMatching = NO_SWITCH;
+	double noMatchDelay;
+	double noMatchCount = 0;
 	StartupBehavior startupBehavior = PERSIST;
+	AutoStartEvent autoStartEvent = AutoStartEvent::NEVER;
 
-	std::vector<WindowSceneSwitch> windowSwitches;
+	double cooldown = 0.;
+	std::chrono::high_resolution_clock::time_point lastMatchTime;
+
+	std::deque<WindowSwitch> windowSwitches;
 	std::vector<std::string> ignoreIdleWindows;
 	std::string lastTitle;
 
-	std::vector<ScreenRegionSwitch> screenRegionSwitches;
-
-	std::vector<OBSWeakSource> pauseScenesSwitches;
-
-	std::vector<std::string> pauseWindowsSwitches;
+	std::deque<ScreenRegionSwitch> screenRegionSwitches;
 
 	std::vector<std::string> ignoreWindowsSwitches;
 
-	std::vector<SceneSequenceSwitch> sceneSequenceSwitches;
-	int sceneSequenceMultiplier = 1;
+	std::deque<SceneSequenceSwitch> sceneSequenceSwitches;
 
-	std::vector<RandomSwitch> randomSwitches;
+	std::deque<RandomSwitch> randomSwitches;
+
+	IdleData idleData;
 
 	FileIOData fileIO;
-	IdleData idleData;
-	std::vector<FileSwitch> fileSwitches;
+	std::deque<FileSwitch> fileSwitches;
 	CURL *curl = nullptr;
 
-	std::vector<ExecutableSceneSwitch> executableSwitches;
+	std::deque<ExecutableSwitch> executableSwitches;
 
-	bool autoStopEnable = false;
-	OBSWeakSource autoStopScene;
+	std::deque<SceneTrigger> sceneTriggers;
 
-	bool autoStartEnable = false;
-	AutoStartType autoStartType = RECORDING;
-	OBSWeakSource autoStartScene;
-	bool autoStartedRecently = false;
+	std::deque<SceneTransition> sceneTransitions;
+	std::deque<DefaultSceneTransition> defaultSceneTransitions;
+	bool checkedDefTransition = false;
 
-	std::vector<SceneTransition> sceneTransitions;
-	std::vector<DefaultSceneTransition> defaultSceneTransitions;
+	std::deque<MediaSwitch> mediaSwitches;
 
-	std::vector<MediaSwitch> mediaSwitches;
+	std::deque<PauseEntry> pauseEntries;
 
-	std::vector<TimeSwitch> timeSwitches;
+	std::deque<TimeSwitch> timeSwitches;
 	QDateTime liveTime;
 
-	std::vector<AudioSwitch> audioSwitches;
+	std::deque<AudioSwitch> audioSwitches;
+	AudioSwitchFallback audioFallback;
+
+	std::deque<SceneGroup> sceneGroups;
 
 	std::vector<int> functionNamesByPriority = std::vector<int>{
 		default_priority_0, default_priority_1, default_priority_2,
@@ -134,9 +149,11 @@ struct SwitcherData {
 	std::vector<int> tabOrder;
 
 	bool hotkeysRegistered = false;
-	obs_hotkey_id startHotkey;
-	obs_hotkey_id stopHotkey;
-	obs_hotkey_id toggleHotkey;
+	obs_hotkey_id startHotkey = 0;
+	obs_hotkey_id stopHotkey = 0;
+	obs_hotkey_id toggleHotkey = 0;
+
+	bool versionChanged(obs_data_t *obj, std::string currentVersion);
 
 	void Thread();
 	void Start();
@@ -145,13 +162,13 @@ struct SwitcherData {
 	bool sceneChangedDuringWait();
 	bool prioFuncsValid();
 	void writeSceneInfoToFile();
-	void setDefaultSceneTransitions();
-	void autoStopStreamAndRecording();
-	void autoStartStreamRecording();
+	void writeToStatusFile(QString status);
 	bool checkPause();
+	void checkDefaultSceneTransitions(bool &match,
+					  OBSWeakSource &transition);
+	void setCurrentDefTransition(OBSWeakSource &transition);
 	void checkSceneSequence(bool &match, OBSWeakSource &scene,
-				 OBSWeakSource &transition,
-				 std::unique_lock<std::mutex> &lock);
+				OBSWeakSource &transition, int &linger);
 	void checkIdleSwitch(bool &match, OBSWeakSource &scene,
 			     OBSWeakSource &transition);
 	void checkWindowTitleSwitch(bool &match, OBSWeakSource &scene,
@@ -172,7 +189,14 @@ struct SwitcherData {
 			     OBSWeakSource &transition);
 	void checkAudioSwitch(bool &match, OBSWeakSource &scene,
 			      OBSWeakSource &transition);
+	void checkAudioSwitchFallback(OBSWeakSource &scene,
+				      OBSWeakSource &transition);
+	void checkNoMatchSwitch(bool &match, OBSWeakSource &scene,
+				OBSWeakSource &transition, int &sleep);
+	void checkSwitchCooldown(bool &match);
+	void checkTriggers();
 
+	void saveSettings(obs_data_t *obj);
 	void saveWindowTitleSwitches(obs_data_t *obj);
 	void saveScreenRegionSwitches(obs_data_t *obj);
 	void savePauseSwitches(obs_data_t *obj);
@@ -185,12 +209,17 @@ struct SwitcherData {
 	void saveMediaSwitches(obs_data_t *obj);
 	void saveTimeSwitches(obs_data_t *obj);
 	void saveAudioSwitches(obs_data_t *obj);
+	void saveSceneGroups(obs_data_t *obj);
+	void saveSceneTriggers(obs_data_t *obj);
 	void saveGeneralSettings(obs_data_t *obj);
 	void saveHotkeys(obs_data_t *obj);
+	void saveVersion(obs_data_t *obj, std::string currentVersion);
 
+	void loadSettings(obs_data_t *obj);
 	void loadWindowTitleSwitches(obs_data_t *obj);
 	void loadScreenRegionSwitches(obs_data_t *obj);
 	void loadPauseSwitches(obs_data_t *obj);
+	void loadOldPauseSwitches(obs_data_t *obj);
 	void loadSceneSequenceSwitches(obs_data_t *obj);
 	void loadSceneTransitions(obs_data_t *obj);
 	void loadIdleSwitches(obs_data_t *obj);
@@ -200,10 +229,13 @@ struct SwitcherData {
 	void loadMediaSwitches(obs_data_t *obj);
 	void loadTimeSwitches(obs_data_t *obj);
 	void loadAudioSwitches(obs_data_t *obj);
+	void loadSceneGroups(obs_data_t *obj);
+	void loadSceneTriggers(obs_data_t *obj);
 	void loadGeneralSettings(obs_data_t *obj);
 	void loadHotkeys(obs_data_t *obj);
 
 	void Prune();
+
 	inline ~SwitcherData() { Stop(); }
 };
 

src/headers/swtich-sequence.hpp

@@ -1,44 +0,0 @@
-#pragma once
-#include <string>
-#include "utility.hpp"
-#include "switch-generic.hpp"
-
-constexpr auto round_trip_func = 1;
-constexpr auto default_priority_1 = round_trip_func;
-
-struct SceneSequenceSwitch : SceneSwitcherEntry {
-	OBSWeakSource startScene;
-	double delay;
-	std::string sceneSequenceStr;
-
-	const char *getType() { return "sequence"; }
-
-	bool valid()
-	{
-		return WeakSourceValid(startScene) &&
-		       (usePreviousScene || WeakSourceValid(scene)) &&
-		       WeakSourceValid(transition);
-	}
-
-	void logSleep(int dur)
-	{
-		blog(LOG_INFO, "Advanced Scene Switcher sequence sleep %d",
-		     dur);
-	}
-
-	inline SceneSequenceSwitch(OBSWeakSource startScene_,
-				    OBSWeakSource scene_,
-				    OBSWeakSource transition_, double delay_,
-				    bool usePreviousScene_, std::string str)
-		: SceneSwitcherEntry(scene_, transition_, usePreviousScene_),
-		  startScene(startScene_),
-		  delay(delay_),
-		  sceneSequenceStr(str)
-	{
-	}
-};
-
-static inline QString MakeSceneSequenceSwitchName(const QString &scene1,
-						   const QString &scene2,
-						   const QString &transition,
-						   double delay);

src/headers/utility.hpp

@@ -1,13 +1,28 @@
 #pragma once
-#include <obs.hpp>
+
 #include <QString>
+#include <QLayout>
+#include <QLabel>
+#include <unordered_map>
+
+#include <obs.hpp>
+#include <obs-module.h>
 #include <obs-frontend-api.h>
 
+static inline bool SceneGroupValid(SceneGroup *group)
+{
+	if (group) {
+		return group->name != invalid_scene_group_name;
+	}
+	return false;
+}
+
 static inline bool WeakSourceValid(obs_weak_source_t *ws)
 {
 	obs_source_t *source = obs_weak_source_get_source(ws);
-	if (source)
+	if (source) {
 		obs_source_release(source);
+	}
 	return !!source;
 }
 
@@ -24,6 +39,26 @@ static inline std::string GetWeakSourceName(obs_weak_source_t *weak_source)
 	return name;
 }
 
+static inline SceneGroup *GetSceneGroupByName(const char *name)
+{
+	if (!switcher) {
+		return nullptr;
+	}
+
+	for (SceneGroup &sg : switcher->sceneGroups) {
+		if (sg.name == name) {
+			return &sg;
+		}
+	}
+
+	return nullptr;
+}
+
+static inline SceneGroup *GetSceneGroupByQString(const QString &name)
+{
+	return GetSceneGroupByName(name.toUtf8().constData());
+}
+
 static inline OBSWeakSource GetWeakSourceByName(const char *name)
 {
 	OBSWeakSource weak;
@@ -82,3 +117,68 @@ static inline OBSWeakSource GetWeakTransitionByQString(const QString &name)
 {
 	return GetWeakTransitionByName(name.toUtf8().constData());
 }
+
+static inline std::string
+getNextDelim(std::string text,
+	     std::unordered_map<std::string, QWidget *> placeholders)
+{
+	size_t pos = std::string::npos;
+	std::string res = "";
+
+	for (const auto &ph : placeholders) {
+		size_t newPos = text.find(ph.first);
+		if (newPos <= pos) {
+			pos = newPos;
+			res = ph.first;
+		}
+	}
+
+	if (pos == std::string::npos) {
+		return "";
+	}
+
+	return res;
+}
+
+/**
+ * Populate layout with labels and widgets based on provided text
+ *
+ * @param text		Text based on which labels are generated and widgets are placed.
+ * @param layout	Layout in which the widgets and labels will be placed.
+ * @param placeholders	Map containing a mapping of placeholder strings to widgets.
+ * @param addStretch	Add addStretch() to layout.
+ */
+static inline void
+placeWidgets(std::string text, QBoxLayout *layout,
+	     std::unordered_map<std::string, QWidget *> placeholders,
+	     bool addStretch = true)
+{
+	std::vector<std::pair<std::string, QWidget *>> labelsWidgetsPairs;
+
+	std::string delim = getNextDelim(text, placeholders);
+	while (delim != "") {
+		size_t pos = text.find(delim);
+		if (pos != std::string::npos) {
+			labelsWidgetsPairs.emplace_back(text.substr(0, pos),
+							placeholders[delim]);
+			text.erase(0, pos + delim.length());
+		}
+		delim = getNextDelim(text, placeholders);
+	}
+
+	if (text != "") {
+		labelsWidgetsPairs.emplace_back(text, nullptr);
+	}
+
+	for (auto &lw : labelsWidgetsPairs) {
+		if (lw.first != "") {
+			layout->addWidget(new QLabel(lw.first.c_str()));
+		}
+		if (lw.second) {
+			layout->addWidget(lw.second);
+		}
+	}
+	if (addStretch) {
+		layout->addStretch();
+	}
+}

src/headers/version.h

@@ -0,0 +1 @@
+extern const char g_GIT_SHA1[];

src/hotkey.cpp

@@ -11,8 +11,9 @@ void startHotkeyFunc(void *data, obs_hotkey_id id, obs_hotkey_t *hotkey,
 	UNUSED_PARAMETER(hotkey);
 
 	if (pressed) {
-		if (!(switcher->th && switcher->th->isRunning()))
+		if (!(switcher->th && switcher->th->isRunning())) {
 			switcher->Start();
+		}
 	}
 }
 
@@ -24,8 +25,9 @@ void stopHotkeyFunc(void *data, obs_hotkey_id id, obs_hotkey_t *hotkey,
 	UNUSED_PARAMETER(hotkey);
 
 	if (pressed) {
-		if (switcher->th && switcher->th->isRunning())
+		if (switcher->th && switcher->th->isRunning()) {
 			switcher->Stop();
+		}
 	}
 }
 
@@ -37,24 +39,28 @@ void startStopToggleHotkeyFunc(void *data, obs_hotkey_id id,
 	UNUSED_PARAMETER(hotkey);
 
 	if (pressed) {
-		if (switcher->th && switcher->th->isRunning())
+		if (switcher->th && switcher->th->isRunning()) {
 			switcher->Stop();
-		else
+		} else {
 			switcher->Start();
+		}
 	}
 }
 
 void registerHotkeys()
 {
 	switcher->startHotkey = obs_hotkey_register_frontend(
-		"startSwitcherHotkey", "Start the Advanced Scene Switcher",
+		"startSwitcherHotkey",
+		obs_module_text("AdvSceneSwitcher.hotkey.startSwitcherHotkey"),
 		startHotkeyFunc, NULL);
 	switcher->stopHotkey = obs_hotkey_register_frontend(
-		"stopSwitcherHotkey", "Stop the Advanced Scene Switcher",
+		"stopSwitcherHotkey",
+		obs_module_text("AdvSceneSwitcher.hotkey.stopSwitcherHotkey"),
 		stopHotkeyFunc, NULL);
 	switcher->toggleHotkey = obs_hotkey_register_frontend(
 		"startStopToggleSwitcherHotkey",
-		"Toggle Start/Stop for the Advanced Scene Switcher",
+		obs_module_text(
+			"AdvSceneSwitcher.hotkey.startStopToggleSwitcherHotkey"),
 		startStopToggleHotkeyFunc, NULL);
 
 	switcher->hotkeysRegistered = true;
@@ -81,8 +87,9 @@ void SwitcherData::saveHotkeys(obs_data_t *obj)
 
 void SwitcherData::loadHotkeys(obs_data_t *obj)
 {
-	if (!switcher->hotkeysRegistered)
+	if (!switcher->hotkeysRegistered) {
 		registerHotkeys();
+	}
 
 	obs_data_array_t *startHotkeyArrray =
 		obs_data_get_array(obj, "startHotkey");

src/osx/advanced-scene-switcher-osx.mm

@@ -17,15 +17,16 @@ void GetWindowList(std::vector<std::string> &windows)
 		for (NSDictionary *app in apps) {
 			// Construct string from NSString accounting for nil
 			std::string name([[app objectForKey:@"kCGWindowName"]
-					    UTF8String],
-				    [[app objectForKey:@"kCGWindowName"]
-					    lengthOfBytesUsingEncoding:
-						    NSUTF8StringEncoding]);
-			std::string owner([[app objectForKey:@"kCGWindowOwnerName"]
-					     UTF8String],
-				     [[app objectForKey:@"kCGWindowOwnerName"]
-					     lengthOfBytesUsingEncoding:
-						     NSUTF8StringEncoding]);
+						 UTF8String],
+					 [[app objectForKey:@"kCGWindowName"]
+						 lengthOfBytesUsingEncoding:
+							 NSUTF8StringEncoding]);
+			std::string owner(
+				[[app objectForKey:@"kCGWindowOwnerName"]
+					UTF8String],
+				[[app objectForKey:@"kCGWindowOwnerName"]
+					lengthOfBytesUsingEncoding:
+						NSUTF8StringEncoding]);
 
 			// Check if name exists
 			if (!name.empty() &&
@@ -53,15 +54,16 @@ void GetWindowList(QStringList &windows)
 		for (NSDictionary *app in apps) {
 			// Construct string from NSString accounting for nil
 			std::string name([[app objectForKey:@"kCGWindowName"]
-					    UTF8String],
-				    [[app objectForKey:@"kCGWindowName"]
-					    lengthOfBytesUsingEncoding:
-						    NSUTF8StringEncoding]);
-			std::string owner([[app objectForKey:@"kCGWindowOwnerName"]
-					     UTF8String],
-				     [[app objectForKey:@"kCGWindowOwnerName"]
-					     lengthOfBytesUsingEncoding:
-						     NSUTF8StringEncoding]);
+						 UTF8String],
+					 [[app objectForKey:@"kCGWindowName"]
+						 lengthOfBytesUsingEncoding:
+							 NSUTF8StringEncoding]);
+			std::string owner(
+				[[app objectForKey:@"kCGWindowOwnerName"]
+					UTF8String],
+				[[app objectForKey:@"kCGWindowOwnerName"]
+					lengthOfBytesUsingEncoding:
+						NSUTF8StringEncoding]);
 
 			// Check if name exists
 			if (!name.empty() &&
@@ -144,15 +146,16 @@ bool isFullscreen(std::string &title)
 		for (NSDictionary *app in apps) {
 			// Construct string from NSString accounting for nil
 			std::string name([[app objectForKey:@"kCGWindowName"]
-					    UTF8String],
-				    [[app objectForKey:@"kCGWindowName"]
-					    lengthOfBytesUsingEncoding:
-						    NSUTF8StringEncoding]);
-			std::string owner([[app objectForKey:@"kCGWindowOwnerName"]
-					     UTF8String],
-				     [[app objectForKey:@"kCGWindowOwnerName"]
-					     lengthOfBytesUsingEncoding:
-						     NSUTF8StringEncoding]);
+						 UTF8String],
+					 [[app objectForKey:@"kCGWindowName"]
+						 lengthOfBytesUsingEncoding:
+							 NSUTF8StringEncoding]);
+			std::string owner(
+				[[app objectForKey:@"kCGWindowOwnerName"]
+					UTF8String],
+				[[app objectForKey:@"kCGWindowOwnerName"]
+					lengthOfBytesUsingEncoding:
+						NSUTF8StringEncoding]);
 
 			// True if switch equals app
 			bool equals = (title == name || title == owner);

src/scene-group.cpp

@@ -0,0 +1,744 @@
+#include <QVBoxLayout>
+#include <QDialogButtonBox>
+#include <random>
+#include "headers/advanced-scene-switcher.hpp"
+#include "headers/utility.hpp"
+
+static QMetaObject::Connection addPulse;
+SceneGroupEditWidget *typeEdit = nullptr;
+
+void SceneGroup::advanceIdx()
+{
+	currentIdx++;
+
+	if (currentIdx >= scenes.size()) {
+		if (repeat) {
+			currentIdx = 0;
+		} else {
+			currentIdx = scenes.size() - 1;
+		}
+	}
+}
+
+OBSWeakSource SceneGroup::getNextSceneCount()
+{
+	currentCount++;
+	if (currentCount >= count) {
+		advanceIdx();
+		currentCount = 0;
+	}
+	return scenes[currentIdx];
+}
+
+OBSWeakSource SceneGroup::getNextSceneTime()
+{
+	if (lastAdvTime.time_since_epoch().count() == 0) {
+		lastAdvTime = std::chrono::high_resolution_clock::now();
+	}
+
+	auto now = std::chrono::high_resolution_clock::now();
+	auto passedTime = std::chrono::duration_cast<std::chrono::milliseconds>(
+		now - lastAdvTime);
+
+	if (passedTime.count() >= time * 1000) {
+		advanceIdx();
+		lastAdvTime = now;
+	}
+
+	return scenes[currentIdx];
+}
+
+OBSWeakSource SceneGroup::getNextSceneRandom()
+{
+	if (scenes.size() == 1) {
+		return *scenes.begin();
+	}
+
+	std::vector<OBSWeakSource> rs(scenes);
+	std::random_device rng;
+	std::mt19937 urng(rng());
+	std::shuffle(rs.begin(), rs.end(), urng);
+	for (OBSWeakSource &s : rs) {
+		if (s == lastRandomScene) {
+			continue;
+		}
+
+		lastRandomScene = s;
+
+		return s;
+	}
+	return nullptr;
+}
+
+OBSWeakSource SceneGroup::getCurrentScene()
+{
+	return scenes[currentIdx];
+}
+
+OBSWeakSource SceneGroup::getNextScene()
+{
+	if (scenes.empty()) {
+		return nullptr;
+	}
+
+	switch (type) {
+	case AdvanceCondition::Count:
+		return getNextSceneCount();
+		break;
+	case AdvanceCondition::Time:
+		return getNextSceneTime();
+		break;
+	case AdvanceCondition::Random:
+		return getNextSceneRandom();
+		break;
+	}
+
+	blog(LOG_INFO, "unknown scene group type!");
+	return nullptr;
+}
+
+bool sceneGroupNameExists(std::string name)
+{
+	obs_source_t *source = obs_get_source_by_name(name.c_str());
+	if (source) {
+		obs_source_release(source);
+		return true;
+	}
+
+	for (SceneGroup &sg : switcher->sceneGroups) {
+		if (sg.name == name) {
+			return true;
+		}
+	}
+
+	return (name == obs_module_text(
+				"AdvSceneSwitcher.selectPreviousScene") ||
+		(name == invalid_scene_group_name));
+}
+
+void AdvSceneSwitcher::on_sceneGroupAdd_clicked()
+{
+	std::string name;
+	QString format{
+		obs_module_text("AdvSceneSwitcher.sceneGroupTab.defaultname")};
+
+	int i = 1;
+	QString placeHolderText = format.arg(i);
+	while ((sceneGroupNameExists(placeHolderText.toUtf8().constData()))) {
+		placeHolderText = format.arg(++i);
+	}
+
+	bool accepted = SGNameDialog::AskForName(
+		this, obs_module_text("AdvSceneSwitcher.sceneGroupTab.add"),
+		obs_module_text("AdvSceneSwitcher.sceneGroupTab.add"), name,
+		placeHolderText);
+
+	if (!accepted) {
+		return;
+	}
+
+	if (name.empty()) {
+		return;
+	}
+
+	if (sceneGroupNameExists(name)) {
+		DisplayMessage(obs_module_text(
+			"AdvSceneSwitcher.sceneGroupTab.exists"));
+		return;
+	}
+
+	{
+		std::lock_guard<std::mutex> lock(switcher->m);
+		switcher->sceneGroups.emplace_back(name);
+	}
+	QString text = QString::fromStdString(name);
+
+	QListWidgetItem *item = new QListWidgetItem(text, ui->sceneGroups);
+	item->setData(Qt::UserRole, text);
+	ui->sceneGroups->setCurrentItem(item);
+
+	ui->sceneGroupAdd->disconnect(addPulse);
+	ui->sceneGroupHelp->setVisible(false);
+
+	emit SceneGroupAdded(QString::fromStdString(name));
+}
+
+void AdvSceneSwitcher::on_sceneGroupRemove_clicked()
+{
+	QListWidgetItem *item = ui->sceneGroups->currentItem();
+	if (!item) {
+		return;
+	}
+
+	QString name;
+	{
+		std::lock_guard<std::mutex> lock(switcher->m);
+		int idx = ui->sceneGroups->currentRow();
+		auto &sg = switcher->sceneGroups;
+		name = QString::fromStdString(sg[idx].name);
+		sg.erase(sg.begin() + idx);
+	}
+
+	delete item;
+
+	emit SceneGroupRemoved(name);
+}
+
+void AdvSceneSwitcher::on_sceneGroupUp_clicked()
+{
+	int index = ui->sceneGroups->currentRow();
+	if (index != -1 && index != 0) {
+		ui->sceneGroups->insertItem(index - 1,
+					    ui->sceneGroups->takeItem(index));
+		ui->sceneGroups->setCurrentRow(index - 1);
+
+		std::lock_guard<std::mutex> lock(switcher->m);
+
+		iter_swap(switcher->sceneGroups.begin() + index,
+			  switcher->sceneGroups.begin() + index - 1);
+	}
+}
+
+void AdvSceneSwitcher::on_sceneGroupDown_clicked()
+{
+	int index = ui->sceneGroups->currentRow();
+	if (index != -1 && index != ui->sceneGroups->count() - 1) {
+		ui->sceneGroups->insertItem(index + 1,
+					    ui->sceneGroups->takeItem(index));
+		ui->sceneGroups->setCurrentRow(index + 1);
+
+		std::lock_guard<std::mutex> lock(switcher->m);
+
+		iter_swap(switcher->sceneGroups.begin() + index,
+			  switcher->sceneGroups.begin() + index + 1);
+	}
+}
+
+SceneGroup *getSelectedSG(Ui_AdvSceneSwitcher *ui)
+{
+	SceneGroup *currentSG = nullptr;
+	QListWidgetItem *sgItem = ui->sceneGroups->currentItem();
+
+	if (!sgItem) {
+		return currentSG;
+	}
+
+	QString sgName = sgItem->data(Qt::UserRole).toString();
+	for (auto &sg : switcher->sceneGroups) {
+		if (sgName.compare(sg.name.c_str()) == 0) {
+			currentSG = &sg;
+			break;
+		}
+	}
+
+	return currentSG;
+}
+
+void AdvSceneSwitcher::on_sceneGroupName_editingFinished()
+{
+	bool nameValid = true;
+
+	SceneGroup *currentSG = getSelectedSG(ui.get());
+	if (!currentSG) {
+		return;
+	}
+
+	QString newName = ui->sceneGroupName->text();
+	QString oldName = QString::fromStdString(currentSG->name);
+
+	if (newName.isEmpty() || newName == oldName) {
+		nameValid = false;
+	}
+
+	if (nameValid && sceneGroupNameExists(newName.toUtf8().constData())) {
+		DisplayMessage(obs_module_text(
+			"AdvSceneSwitcher.sceneGroupTab.exists"));
+		nameValid = false;
+	}
+
+	{
+		std::lock_guard<std::mutex> lock(switcher->m);
+		if (nameValid) {
+			currentSG->name = newName.toUtf8().constData();
+			QListWidgetItem *sgItem =
+				ui->sceneGroups->currentItem();
+			sgItem->setData(Qt::UserRole, newName);
+			sgItem->setText(newName);
+		} else {
+			ui->sceneGroupName->setText(oldName);
+		}
+	}
+	emit SceneGroupRenamed(oldName, newName);
+}
+
+void AdvSceneSwitcher::SetEditSceneGroup(SceneGroup &sg)
+{
+	ui->sceneGroupName->setText(sg.name.c_str());
+	ui->sceneGroupScenes->clear();
+
+	for (auto &s : sg.scenes) {
+		QString sceneName =
+			QString::fromStdString(GetWeakSourceName(s));
+		QVariant v = QVariant::fromValue(sceneName);
+		QListWidgetItem *item =
+			new QListWidgetItem(sceneName, ui->sceneGroupScenes);
+		item->setData(Qt::UserRole, v);
+	}
+
+	ui->sceneGroupEdit->setDisabled(false);
+	typeEdit->SetEditSceneGroup(&sg);
+
+	if (sg.scenes.size() == 0) {
+		ui->sceneGroupScenesHelp->setVisible(true);
+	} else {
+		ui->sceneGroupScenesHelp->setVisible(false);
+	}
+}
+
+void AdvSceneSwitcher::on_sceneGroups_currentRowChanged(int idx)
+{
+	if (loading) {
+		return;
+	}
+
+	if (idx == -1) {
+		ui->sceneGroupEdit->setDisabled(true);
+		return;
+	}
+
+	QListWidgetItem *item = ui->sceneGroups->item(idx);
+	QString sgName = item->data(Qt::UserRole).toString();
+
+	for (auto &sg : switcher->sceneGroups) {
+		if (sgName.compare(sg.name.c_str()) == 0) {
+			SetEditSceneGroup(sg);
+			break;
+		}
+	}
+}
+
+void AdvSceneSwitcher::on_sceneGroupSceneAdd_clicked()
+{
+	std::lock_guard<std::mutex> lock(switcher->m);
+	SceneGroup *currentSG = getSelectedSG(ui.get());
+	if (!currentSG) {
+		return;
+	}
+
+	QString sceneName = ui->sceneGroupSceneSelection->currentText();
+
+	if (sceneName.isEmpty()) {
+		return;
+	}
+
+	OBSWeakSource source = GetWeakSourceByQString(sceneName);
+	if (!source) {
+		return;
+	}
+
+	QVariant v = QVariant::fromValue(sceneName);
+	QListWidgetItem *item =
+		new QListWidgetItem(sceneName, ui->sceneGroupScenes);
+	item->setData(Qt::UserRole, v);
+
+	currentSG->scenes.emplace_back(source);
+
+	ui->sceneGroupScenesHelp->setVisible(false);
+}
+
+void AdvSceneSwitcher::on_sceneGroupSceneRemove_clicked()
+{
+	std::lock_guard<std::mutex> lock(switcher->m);
+	SceneGroup *currentSG = getSelectedSG(ui.get());
+	if (!currentSG) {
+		return;
+	}
+
+	int idx = ui->sceneGroupScenes->currentRow();
+	if (idx == -1) {
+		return;
+	}
+
+	auto &scenes = currentSG->scenes;
+	scenes.erase(scenes.begin() + idx);
+
+	auto item = ui->sceneGroupScenes->currentItem();
+	delete item;
+}
+
+void AdvSceneSwitcher::on_sceneGroupSceneUp_clicked()
+{
+	std::lock_guard<std::mutex> lock(switcher->m);
+	SceneGroup *currentSG = getSelectedSG(ui.get());
+	if (!currentSG) {
+		return;
+	}
+
+	int index = ui->sceneGroupScenes->currentRow();
+	if (index != -1 && index != 0) {
+		ui->sceneGroupScenes->insertItem(
+			index - 1, ui->sceneGroupScenes->takeItem(index));
+		ui->sceneGroupScenes->setCurrentRow(index - 1);
+
+		iter_swap(currentSG->scenes.begin() + index,
+			  currentSG->scenes.begin() + index - 1);
+	}
+}
+
+void AdvSceneSwitcher::on_sceneGroupSceneDown_clicked()
+{
+	std::lock_guard<std::mutex> lock(switcher->m);
+	SceneGroup *currentSG = getSelectedSG(ui.get());
+	if (!currentSG) {
+		return;
+	}
+
+	int index = ui->sceneGroupScenes->currentRow();
+	if (index != -1 && index != ui->sceneGroupScenes->count() - 1) {
+		ui->sceneGroupScenes->insertItem(
+			index + 1, ui->sceneGroupScenes->takeItem(index));
+		ui->sceneGroupScenes->setCurrentRow(index + 1);
+
+		iter_swap(currentSG->scenes.begin() + index,
+			  currentSG->scenes.begin() + index + 1);
+	}
+}
+
+void SwitcherData::saveSceneGroups(obs_data_t *obj)
+{
+	obs_data_array_t *sceneGroupArray = obs_data_array_create();
+	for (SceneGroup &sg : switcher->sceneGroups) {
+		obs_data_t *array_obj = obs_data_create();
+
+		obs_data_set_string(array_obj, "name", sg.name.c_str());
+		obs_data_set_int(array_obj, "type", static_cast<int>(sg.type));
+
+		obs_data_array_t *scenesArray = obs_data_array_create();
+
+		for (OBSWeakSource s : sg.scenes) {
+			obs_data_t *sceneArray_obj = obs_data_create();
+			obs_source_t *source = obs_weak_source_get_source(s);
+
+			if (source) {
+				const char *name = obs_source_get_name(source);
+				obs_data_set_string(sceneArray_obj, "scene",
+						    name);
+			}
+
+			obs_source_release(source);
+
+			obs_data_array_push_back(scenesArray, sceneArray_obj);
+			obs_data_release(sceneArray_obj);
+		}
+		obs_data_set_array(array_obj, "scenes", scenesArray);
+		obs_data_array_release(scenesArray);
+
+		obs_data_set_int(array_obj, "count", sg.count);
+		obs_data_set_double(array_obj, "time", sg.time);
+		obs_data_set_bool(array_obj, "repeat", sg.repeat);
+
+		obs_data_array_push_back(sceneGroupArray, array_obj);
+		obs_data_release(array_obj);
+	}
+	obs_data_set_array(obj, "sceneGroups", sceneGroupArray);
+	obs_data_array_release(sceneGroupArray);
+}
+
+void SwitcherData::loadSceneGroups(obs_data_t *obj)
+{
+	switcher->sceneGroups.clear();
+
+	obs_data_array_t *sceneGroupArray =
+		obs_data_get_array(obj, "sceneGroups");
+	size_t count = obs_data_array_count(sceneGroupArray);
+
+	for (size_t i = 0; i < count; i++) {
+		obs_data_t *array_obj = obs_data_array_item(sceneGroupArray, i);
+
+		const char *name = obs_data_get_string(array_obj, "name");
+		AdvanceCondition type = static_cast<AdvanceCondition>(
+			obs_data_get_int(array_obj, "type"));
+
+		std::vector<OBSWeakSource> scenes;
+		obs_data_array_t *scenesArray =
+			obs_data_get_array(array_obj, "scenes");
+		size_t scenesCount = obs_data_array_count(scenesArray);
+		for (size_t j = 0; j < scenesCount; j++) {
+			obs_data_t *scenesArray_obj =
+				obs_data_array_item(scenesArray, j);
+			const char *scene =
+				obs_data_get_string(scenesArray_obj, "scene");
+			scenes.emplace_back(GetWeakSourceByName(scene));
+			obs_data_release(scenesArray_obj);
+		}
+		obs_data_array_release(scenesArray);
+
+		int count = obs_data_get_int(array_obj, "count");
+		double time = obs_data_get_double(array_obj, "time");
+		bool repeat = obs_data_get_bool(array_obj, "repeat");
+
+		switcher->sceneGroups.emplace_back(name, type, scenes, count,
+						   time, repeat);
+
+		obs_data_release(array_obj);
+	}
+	obs_data_array_release(sceneGroupArray);
+}
+
+void AdvSceneSwitcher::setupSceneGroupTab()
+{
+	populateSceneSelection(ui->sceneGroupSceneSelection);
+
+	for (auto &sg : switcher->sceneGroups) {
+		QString text = QString::fromStdString(sg.name);
+
+		QListWidgetItem *item =
+			new QListWidgetItem(text, ui->sceneGroups);
+		item->setData(Qt::UserRole, text);
+	}
+
+	if (switcher->sceneGroups.size() == 0) {
+		addPulse = PulseWidget(ui->sceneGroupAdd, QColor(Qt::green));
+		ui->sceneGroupHelp->setVisible(true);
+	} else {
+		ui->sceneGroupHelp->setVisible(false);
+	}
+
+	typeEdit = new SceneGroupEditWidget();
+	ui->sceneGroupTypeEdit->addWidget(typeEdit);
+
+	ui->sceneGroupEdit->setDisabled(true);
+}
+
+SGNameDialog::SGNameDialog(QWidget *parent) : QDialog(parent)
+{
+	setModal(true);
+	setWindowModality(Qt::WindowModality::WindowModal);
+	setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
+	setFixedWidth(555);
+	setMinimumHeight(100);
+	QVBoxLayout *layout = new QVBoxLayout;
+	setLayout(layout);
+
+	label = new QLabel(this);
+	layout->addWidget(label);
+	label->setText("Set Text");
+
+	userText = new QLineEdit(this);
+	layout->addWidget(userText);
+
+	QDialogButtonBox *buttonbox = new QDialogButtonBox(
+		QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
+	layout->addWidget(buttonbox);
+	buttonbox->setCenterButtons(true);
+	connect(buttonbox, &QDialogButtonBox::accepted, this, &QDialog::accept);
+	connect(buttonbox, &QDialogButtonBox::rejected, this, &QDialog::reject);
+}
+
+static bool IsWhitespace(char ch)
+{
+	return ch == ' ' || ch == '\t';
+}
+
+static void CleanWhitespace(std::string &str)
+{
+	while (str.size() && IsWhitespace(str.back()))
+		str.erase(str.end() - 1);
+	while (str.size() && IsWhitespace(str.front()))
+		str.erase(str.begin());
+}
+
+bool SGNameDialog::AskForName(QWidget *parent, const QString &title,
+			      const QString &text, std::string &userTextInput,
+			      const QString &placeHolder, int maxSize)
+{
+	if (maxSize <= 0 || maxSize > 32767) {
+		maxSize = 170;
+	}
+
+	SGNameDialog dialog(parent);
+	dialog.setWindowTitle(title);
+
+	dialog.label->setText(text);
+	dialog.userText->setMaxLength(maxSize);
+	dialog.userText->setText(placeHolder);
+	dialog.userText->selectAll();
+
+	if (dialog.exec() != DialogCode::Accepted) {
+		return false;
+	}
+	userTextInput = dialog.userText->text().toUtf8().constData();
+	CleanWhitespace(userTextInput);
+	return true;
+}
+
+void populateTypeSelection(QComboBox *list)
+{
+	list->addItem(
+		obs_module_text("AdvSceneSwitcher.sceneGroupTab.type.count"));
+	list->addItem(
+		obs_module_text("AdvSceneSwitcher.sceneGroupTab.type.time"));
+	list->addItem(
+		obs_module_text("AdvSceneSwitcher.sceneGroupTab.type.random"));
+}
+
+SceneGroupEditWidget::SceneGroupEditWidget()
+{
+	type = new QComboBox();
+	populateTypeSelection(type);
+
+	QWidget::connect(type, SIGNAL(currentIndexChanged(int)), this,
+			 SLOT(TypeChanged(int)));
+
+	QHBoxLayout *typeLayout = new QHBoxLayout();
+	typeLayout->setContentsMargins(0, 0, 0, 0);
+
+	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
+		{"{{type}}", type}};
+	placeWidgets(
+		obs_module_text("AdvSceneSwitcher.sceneGroupTab.edit.type"),
+		typeLayout, widgetPlaceholders);
+
+	countEdit = new QWidget();
+	count = new QSpinBox();
+
+	count->setMinimum(1);
+	count->setMaximum(999);
+
+	QWidget::connect(count, SIGNAL(valueChanged(int)), this,
+			 SLOT(CountChanged(int)));
+
+	QHBoxLayout *countLayout = new QHBoxLayout(countEdit);
+	countLayout->setContentsMargins(0, 0, 0, 0);
+
+	widgetPlaceholders = {{"{{count}}", count}};
+	placeWidgets(
+		obs_module_text("AdvSceneSwitcher.sceneGroupTab.edit.count"),
+		countLayout, widgetPlaceholders);
+
+	timeEdit = new QWidget();
+	time = new QDoubleSpinBox();
+
+	time->setMinimum(0.0);
+	time->setMaximum(99999999.00);
+	time->setSuffix("s");
+
+	QWidget::connect(time, SIGNAL(valueChanged(double)), this,
+			 SLOT(TimeChanged(double)));
+
+	QHBoxLayout *timeLayout = new QHBoxLayout(timeEdit);
+	timeLayout->setContentsMargins(0, 0, 0, 0);
+
+	widgetPlaceholders = {{"{{time}}", time}};
+	placeWidgets(
+		obs_module_text("AdvSceneSwitcher.sceneGroupTab.edit.time"),
+		timeLayout, widgetPlaceholders);
+
+	repeat = new QCheckBox(
+		obs_module_text("AdvSceneSwitcher.sceneGroupTab.edit.repeat"));
+
+	QWidget::connect(repeat, SIGNAL(stateChanged(int)), this,
+			 SLOT(RepeatChanged(int)));
+
+	random = new QLabel(
+		obs_module_text("AdvSceneSwitcher.sceneGroupTab.edit.random"));
+
+	QVBoxLayout *mainLayout = new QVBoxLayout;
+	mainLayout->setContentsMargins(0, 0, 0, 0);
+	mainLayout->addLayout(typeLayout);
+	mainLayout->addWidget(countEdit);
+	mainLayout->addWidget(timeEdit);
+	mainLayout->addWidget(repeat);
+	mainLayout->addWidget(random);
+
+	setLayout(mainLayout);
+
+	countEdit->setVisible(false);
+	timeEdit->setVisible(false);
+	repeat->setVisible(false);
+	random->setVisible(false);
+
+	sceneGroup = nullptr;
+}
+
+void SceneGroupEditWidget::ShowCurrentTypeEdit()
+{
+	if (!sceneGroup) {
+		return;
+	}
+
+	countEdit->setVisible(false);
+	timeEdit->setVisible(false);
+	repeat->setVisible(false);
+	random->setVisible(false);
+
+	switch (sceneGroup->type) {
+	case AdvanceCondition::Count:
+		countEdit->setVisible(true);
+		repeat->setVisible(true);
+		break;
+	case AdvanceCondition::Time:
+		timeEdit->setVisible(true);
+		repeat->setVisible(true);
+		break;
+	case AdvanceCondition::Random:
+		random->setVisible(true);
+		break;
+	}
+}
+
+void SceneGroupEditWidget::SetEditSceneGroup(SceneGroup *sg)
+{
+	if (!sg) {
+		return;
+	}
+
+	sceneGroup = sg;
+	type->setCurrentIndex(static_cast<int>(sg->type));
+	count->setValue(sg->count);
+	time->setValue(sg->time);
+	repeat->setChecked(sg->repeat);
+	ShowCurrentTypeEdit();
+}
+
+void SceneGroupEditWidget::TypeChanged(int type)
+{
+	if (!sceneGroup) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	sceneGroup->type = static_cast<AdvanceCondition>(type);
+
+	ShowCurrentTypeEdit();
+}
+
+void SceneGroupEditWidget::CountChanged(int count)
+{
+	if (!sceneGroup) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	sceneGroup->count = count;
+}
+
+void SceneGroupEditWidget::TimeChanged(double time)
+{
+	if (!sceneGroup) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	sceneGroup->time = time;
+}
+
+void SceneGroupEditWidget::RepeatChanged(int state)
+{
+	if (!sceneGroup) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	sceneGroup->repeat = state;
+}

src/scene-trigger.cpp

@@ -0,0 +1,588 @@
+#include <thread>
+
+#include "headers/advanced-scene-switcher.hpp"
+#include "headers/utility.hpp"
+
+bool SceneTrigger::pause = false;
+static QMetaObject::Connection addPulse;
+
+void AdvSceneSwitcher::on_triggerAdd_clicked()
+{
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switcher->sceneTriggers.emplace_back();
+
+	listAddClicked(ui->sceneTriggers,
+		       new SceneTriggerWidget(this,
+					      &switcher->sceneTriggers.back()),
+		       ui->triggerAdd, &addPulse);
+
+	ui->triggerHelp->setVisible(false);
+}
+
+void AdvSceneSwitcher::on_triggerRemove_clicked()
+{
+	QListWidgetItem *item = ui->sceneTriggers->currentItem();
+	if (!item) {
+		return;
+	}
+
+	{
+		std::lock_guard<std::mutex> lock(switcher->m);
+		int idx = ui->sceneTriggers->currentRow();
+		auto &switches = switcher->sceneTriggers;
+		switches.erase(switches.begin() + idx);
+	}
+
+	delete item;
+}
+
+void AdvSceneSwitcher::on_triggerUp_clicked()
+{
+	int index = ui->sceneTriggers->currentRow();
+	if (!listMoveUp(ui->sceneTriggers)) {
+		return;
+	}
+
+	SceneTriggerWidget *s1 =
+		(SceneTriggerWidget *)ui->sceneTriggers->itemWidget(
+			ui->sceneTriggers->item(index));
+	SceneTriggerWidget *s2 =
+		(SceneTriggerWidget *)ui->sceneTriggers->itemWidget(
+			ui->sceneTriggers->item(index - 1));
+	SceneTriggerWidget::swapSwitchData(s1, s2);
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+
+	std::swap(switcher->sceneTriggers[index],
+		  switcher->sceneTriggers[index - 1]);
+}
+
+void AdvSceneSwitcher::on_triggerDown_clicked()
+{
+	int index = ui->sceneTriggers->currentRow();
+
+	if (!listMoveDown(ui->sceneTriggers)) {
+		return;
+	}
+
+	SceneTriggerWidget *s1 =
+		(SceneTriggerWidget *)ui->sceneTriggers->itemWidget(
+			ui->sceneTriggers->item(index));
+	SceneTriggerWidget *s2 =
+		(SceneTriggerWidget *)ui->sceneTriggers->itemWidget(
+			ui->sceneTriggers->item(index + 1));
+	SceneTriggerWidget::swapSwitchData(s1, s2);
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+
+	std::swap(switcher->sceneTriggers[index],
+		  switcher->sceneTriggers[index + 1]);
+}
+
+void SceneTrigger::logMatch()
+{
+	std::string sceneName = "";
+	std::string statusName = "";
+	std::string actionName = "";
+
+	switch (triggerType) {
+	case sceneTriggerType::NONE:
+		statusName = "NONE";
+		break;
+	case sceneTriggerType::SCENE_ACTIVE:
+		statusName = "SCENE ACTIVE";
+		break;
+	case sceneTriggerType::SCENE_INACTIVE:
+		statusName = "SCENE INACTIVE";
+		break;
+	case sceneTriggerType::SCENE_LEAVE:
+		statusName = "SCENE LEAVE";
+		break;
+	default:
+		break;
+	}
+
+	switch (triggerAction) {
+	case sceneTriggerAction::NONE:
+		actionName = "NONE";
+		break;
+	case sceneTriggerAction::START_RECORDING:
+		actionName = "START RECORDING";
+		break;
+	case sceneTriggerAction::PAUSE_RECORDING:
+		actionName = "PAUSE RECORDING";
+		break;
+	case sceneTriggerAction::UNPAUSE_RECORDING:
+		actionName = "UNPAUSE RECORDING";
+		break;
+	case sceneTriggerAction::STOP_RECORDING:
+		actionName = "STOP RECORDING";
+		break;
+	case sceneTriggerAction::START_STREAMING:
+		actionName = "START STREAMING";
+		break;
+	case sceneTriggerAction::STOP_STREAMING:
+		actionName = "STOP STREAMING";
+		break;
+	case sceneTriggerAction::START_REPLAY_BUFFER:
+		actionName = "START REPLAY BUFFER";
+		break;
+	case sceneTriggerAction::STOP_REPLAY_BUFFER:
+		actionName = "STOP REPLAY BUFFER";
+		break;
+	case sceneTriggerAction::MUTE_SOURCE:
+		actionName = "MUTE (" + GetWeakSourceName(audioSource) + ")";
+		break;
+	default:
+		actionName = "UNKOWN";
+		break;
+	}
+
+	blog(LOG_INFO,
+	     "scene '%s' in status '%s' triggering action '%s' after %f seconds",
+	     GetWeakSourceName(scene).c_str(), statusName.c_str(),
+	     actionName.c_str(), duration);
+}
+
+void frontEndActionThread(sceneTriggerAction action, double delay)
+{
+	long long mil = delay * 1000;
+	std::this_thread::sleep_for(std::chrono::milliseconds(mil));
+
+	switch (action) {
+	case sceneTriggerAction::NONE:
+		break;
+	case sceneTriggerAction::START_RECORDING:
+		obs_frontend_recording_start();
+		break;
+	case sceneTriggerAction::PAUSE_RECORDING:
+		obs_frontend_recording_pause(true);
+		break;
+	case sceneTriggerAction::UNPAUSE_RECORDING:
+		obs_frontend_recording_pause(false);
+		break;
+	case sceneTriggerAction::STOP_RECORDING:
+		obs_frontend_recording_stop();
+		break;
+	case sceneTriggerAction::START_STREAMING:
+		obs_frontend_streaming_start();
+		break;
+	case sceneTriggerAction::STOP_STREAMING:
+		obs_frontend_streaming_stop();
+		break;
+	case sceneTriggerAction::START_REPLAY_BUFFER:
+		obs_frontend_replay_buffer_start();
+		break;
+	case sceneTriggerAction::STOP_REPLAY_BUFFER:
+		obs_frontend_replay_buffer_stop();
+		break;
+	case sceneTriggerAction::MUTE_SOURCE:
+		obs_frontend_replay_buffer_stop();
+		break;
+	default:
+		break;
+	}
+}
+
+void muteThread(OBSWeakSource source, double delay)
+{
+	long long mil = delay * 1000;
+	std::this_thread::sleep_for(std::chrono::milliseconds(mil));
+
+	auto s = obs_weak_source_get_source(source);
+	obs_source_set_muted(s, true);
+	obs_source_release(s);
+}
+
+bool isFrontendAction(sceneTriggerAction triggerAction)
+{
+	return triggerAction == sceneTriggerAction::START_RECORDING ||
+	       triggerAction == sceneTriggerAction::PAUSE_RECORDING ||
+	       triggerAction == sceneTriggerAction::UNPAUSE_RECORDING ||
+	       triggerAction == sceneTriggerAction::STOP_RECORDING ||
+	       triggerAction == sceneTriggerAction::START_STREAMING ||
+	       triggerAction == sceneTriggerAction::STOP_STREAMING ||
+	       triggerAction == sceneTriggerAction::START_REPLAY_BUFFER ||
+	       triggerAction == sceneTriggerAction::STOP_REPLAY_BUFFER;
+}
+
+void SceneTrigger::performAction()
+{
+	if (triggerAction == sceneTriggerAction::NONE) {
+		return;
+	}
+
+	std::thread t;
+
+	if (isFrontendAction(triggerAction)) {
+		t = std::thread(frontEndActionThread, triggerAction, duration);
+	} else {
+		t = std::thread(muteThread, audioSource, duration);
+	}
+
+	t.detach();
+}
+
+bool SceneTrigger::checkMatch(OBSWeakSource previousScene)
+{
+	OBSSource source = obs_frontend_get_current_scene();
+	OBSWeakSource currentScene = obs_source_get_weak_source(source);
+	obs_source_release(source);
+	obs_weak_source_release(currentScene);
+
+	switch (triggerType) {
+	case sceneTriggerType::NONE:
+		return false;
+	case sceneTriggerType::SCENE_ACTIVE:
+		return currentScene == scene;
+	case sceneTriggerType::SCENE_INACTIVE:
+		return currentScene != scene;
+	case sceneTriggerType::SCENE_LEAVE:
+		return previousScene == scene;
+	}
+	return false;
+}
+
+void SwitcherData::checkTriggers()
+{
+	if (SceneTrigger::pause || stop) {
+		return;
+	}
+
+	for (auto &t : sceneTriggers) {
+		if (t.checkMatch(previousScene)) {
+			t.logMatch();
+			t.performAction();
+		}
+	}
+}
+
+void SwitcherData::saveSceneTriggers(obs_data_t *obj)
+{
+	obs_data_array_t *triggerArray = obs_data_array_create();
+	for (auto &s : switcher->sceneTriggers) {
+		obs_data_t *array_obj = obs_data_create();
+
+		s.save(array_obj);
+		obs_data_array_push_back(triggerArray, array_obj);
+
+		obs_data_release(array_obj);
+	}
+	obs_data_set_array(obj, "triggers", triggerArray);
+	obs_data_array_release(triggerArray);
+}
+
+// To be removed in future version
+void loadOldAutoStopStart(obs_data_t *obj)
+{
+	typedef enum {
+		RECORDING = 0,
+		STREAMING = 1,
+		RECORINDGSTREAMING = 2
+	} AutoStartStopType;
+
+	if (obs_data_get_bool(obj, "autoStopEnable")) {
+		std::string autoStopScene =
+			obs_data_get_string(obj, "autoStopSceneName");
+		int action = obs_data_get_int(obj, "autoStopType");
+
+		if (action == RECORDING) {
+			switcher->sceneTriggers.emplace_back();
+			auto &s = switcher->sceneTriggers.back();
+			s.scene = GetWeakSourceByName(autoStopScene.c_str());
+			s.triggerType = sceneTriggerType::SCENE_ACTIVE;
+			s.triggerAction = sceneTriggerAction::STOP_RECORDING;
+		}
+
+		if (action == STREAMING) {
+			switcher->sceneTriggers.emplace_back();
+			auto &s = switcher->sceneTriggers.back();
+			s.scene = GetWeakSourceByName(autoStopScene.c_str());
+			s.triggerType = sceneTriggerType::SCENE_ACTIVE;
+			s.triggerAction = sceneTriggerAction::STOP_STREAMING;
+		}
+
+		if (action == RECORINDGSTREAMING) {
+			switcher->sceneTriggers.emplace_back();
+			auto &s = switcher->sceneTriggers.back();
+			s.scene = GetWeakSourceByName(autoStopScene.c_str());
+			s.triggerType = sceneTriggerType::SCENE_ACTIVE;
+			s.triggerAction = sceneTriggerAction::STOP_RECORDING;
+
+			switcher->sceneTriggers.emplace_back();
+			auto &s2 = switcher->sceneTriggers.back();
+			s2.scene = GetWeakSourceByName(autoStopScene.c_str());
+			s2.triggerType = sceneTriggerType::SCENE_ACTIVE;
+			s2.triggerAction = sceneTriggerAction::STOP_STREAMING;
+		}
+	}
+
+	if (obs_data_get_bool(obj, "autoStartEnable")) {
+		std::string autoStartScene =
+			obs_data_get_string(obj, "autoStartSceneName");
+		int action = obs_data_get_int(obj, "autoStartType");
+
+		if (action == RECORDING) {
+			switcher->sceneTriggers.emplace_back();
+			auto &s = switcher->sceneTriggers.back();
+			s.scene = GetWeakSourceByName(autoStartScene.c_str());
+			s.triggerType = sceneTriggerType::SCENE_ACTIVE;
+			s.triggerAction = sceneTriggerAction::START_RECORDING;
+		}
+
+		if (action == STREAMING) {
+			switcher->sceneTriggers.emplace_back();
+			auto &s = switcher->sceneTriggers.back();
+			s.scene = GetWeakSourceByName(autoStartScene.c_str());
+			s.triggerType = sceneTriggerType::SCENE_ACTIVE;
+			s.triggerAction = sceneTriggerAction::START_STREAMING;
+		}
+
+		if (action == RECORINDGSTREAMING) {
+			switcher->sceneTriggers.emplace_back();
+			auto &s = switcher->sceneTriggers.back();
+			s.scene = GetWeakSourceByName(autoStartScene.c_str());
+			s.triggerType = sceneTriggerType::SCENE_ACTIVE;
+			s.triggerAction = sceneTriggerAction::START_RECORDING;
+
+			switcher->sceneTriggers.emplace_back();
+			auto &s2 = switcher->sceneTriggers.back();
+			s2.scene = GetWeakSourceByName(autoStartScene.c_str());
+			s2.triggerType = sceneTriggerType::SCENE_ACTIVE;
+			s2.triggerAction = sceneTriggerAction::START_STREAMING;
+		}
+	}
+}
+
+void SwitcherData::loadSceneTriggers(obs_data_t *obj)
+{
+	switcher->sceneTriggers.clear();
+
+	loadOldAutoStopStart(obj);
+
+	obs_data_array_t *triggerArray = obs_data_get_array(obj, "triggers");
+	size_t count = obs_data_array_count(triggerArray);
+
+	for (size_t i = 0; i < count; i++) {
+		obs_data_t *array_obj = obs_data_array_item(triggerArray, i);
+
+		switcher->sceneTriggers.emplace_back();
+		sceneTriggers.back().load(array_obj);
+
+		obs_data_release(array_obj);
+	}
+	obs_data_array_release(triggerArray);
+}
+
+void AdvSceneSwitcher::setupTriggerTab()
+{
+	for (auto &s : switcher->sceneTriggers) {
+		QListWidgetItem *item;
+		item = new QListWidgetItem(ui->sceneTriggers);
+		ui->sceneTriggers->addItem(item);
+		SceneTriggerWidget *sw = new SceneTriggerWidget(this, &s);
+		item->setSizeHint(sw->minimumSizeHint());
+		ui->sceneTriggers->setItemWidget(item, sw);
+	}
+
+	if (switcher->sceneTriggers.size() == 0) {
+		addPulse = PulseWidget(ui->triggerAdd, QColor(Qt::green));
+		ui->triggerHelp->setVisible(true);
+	} else {
+		ui->triggerHelp->setVisible(false);
+	}
+}
+
+void SceneTrigger::save(obs_data_t *obj)
+{
+	obs_source_t *sceneSource = obs_weak_source_get_source(scene);
+	const char *sceneName = obs_source_get_name(sceneSource);
+	obs_data_set_string(obj, "scene", sceneName);
+	obs_source_release(sceneSource);
+
+	obs_data_set_int(obj, "triggerType", static_cast<int>(triggerType));
+	obs_data_set_int(obj, "triggerAction", static_cast<int>(triggerAction));
+	obs_data_set_double(obj, "duration", duration);
+
+	obs_source_t *source = obs_weak_source_get_source(audioSource);
+	const char *audioSourceName = obs_source_get_name(source);
+	obs_data_set_string(obj, "audioSource", audioSourceName);
+	obs_source_release(source);
+}
+
+void SceneTrigger::load(obs_data_t *obj)
+{
+	const char *sceneName = obs_data_get_string(obj, "scene");
+	scene = GetWeakSourceByName(sceneName);
+
+	triggerType = static_cast<sceneTriggerType>(
+		obs_data_get_int(obj, "triggerType"));
+	triggerAction = static_cast<sceneTriggerAction>(
+		obs_data_get_int(obj, "triggerAction"));
+	duration = obs_data_get_double(obj, "duration");
+
+	const char *audioSourceName = obs_data_get_string(obj, "audioSource");
+	audioSource = GetWeakSourceByName(audioSourceName);
+}
+
+inline void populateTriggers(QComboBox *list)
+{
+	list->addItem(obs_module_text(
+		"AdvSceneSwitcher.sceneTriggerTab.sceneTriggerType.none"));
+	list->addItem(obs_module_text(
+		"AdvSceneSwitcher.sceneTriggerTab.sceneTriggerType.sceneActive"));
+	list->addItem(obs_module_text(
+		"AdvSceneSwitcher.sceneTriggerTab.sceneTriggerType.sceneInactive"));
+	list->addItem(obs_module_text(
+		"AdvSceneSwitcher.sceneTriggerTab.sceneTriggerType.sceneLeave"));
+}
+
+inline void populateActions(QComboBox *list)
+{
+	list->addItem(obs_module_text(
+		"AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.none"));
+	list->addItem(obs_module_text(
+		"AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.startRecording"));
+	list->addItem(obs_module_text(
+		"AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.pauseRecording"));
+	list->addItem(obs_module_text(
+		"AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.unpauseRecording"));
+	list->addItem(obs_module_text(
+		"AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.stopRecording"));
+	list->addItem(obs_module_text(
+		"AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.startStreaming"));
+	list->addItem(obs_module_text(
+		"AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.stopStreaming"));
+	list->addItem(obs_module_text(
+		"AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.startReplayBuffer"));
+	list->addItem(obs_module_text(
+		"AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.stopReplayBuffer"));
+	list->addItem(obs_module_text(
+		"AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.muteSource"));
+}
+
+SceneTriggerWidget::SceneTriggerWidget(QWidget *parent, SceneTrigger *s)
+	: SwitchWidget(parent, s, false, false)
+{
+	triggers = new QComboBox();
+	actions = new QComboBox();
+	duration = new QDoubleSpinBox();
+	audioSources = new QComboBox();
+
+	duration->setMinimum(0.0);
+	duration->setMaximum(99.000000);
+	duration->setSuffix("s");
+
+	QWidget::connect(triggers, SIGNAL(currentIndexChanged(int)), this,
+			 SLOT(TriggerTypeChanged(int)));
+	QWidget::connect(actions, SIGNAL(currentIndexChanged(int)), this,
+			 SLOT(TriggerActionChanged(int)));
+	QWidget::connect(duration, SIGNAL(valueChanged(double)), this,
+			 SLOT(DurationChanged(double)));
+	QWidget::connect(audioSources,
+			 SIGNAL(currentTextChanged(const QString &)), this,
+			 SLOT(AudioSourceChanged(const QString &)));
+
+	populateTriggers(triggers);
+	populateActions(actions);
+	AdvSceneSwitcher::populateAudioSelection(audioSources);
+
+	if (s) {
+		triggers->setCurrentIndex(static_cast<int>(s->triggerType));
+		actions->setCurrentIndex(static_cast<int>(s->triggerAction));
+		duration->setValue(s->duration);
+
+		audioSources->setCurrentText(
+			GetWeakSourceName(s->audioSource).c_str());
+
+		if (s->triggerAction == sceneTriggerAction::MUTE_SOURCE) {
+			audioSources->show();
+		} else {
+			audioSources->hide();
+		}
+	}
+
+	QHBoxLayout *mainLayout = new QHBoxLayout;
+	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
+		{"{{triggers}}", triggers},
+		{"{{actions}}", actions},
+		{"{{audioSources}}", audioSources},
+		{"{{duration}}", duration},
+		{"{{scenes}}", scenes}};
+	placeWidgets(obs_module_text("AdvSceneSwitcher.sceneTriggerTab.entry"),
+		     mainLayout, widgetPlaceholders);
+	setLayout(mainLayout);
+
+	switchData = s;
+
+	loading = false;
+}
+
+SceneTrigger *SceneTriggerWidget::getSwitchData()
+{
+	return switchData;
+}
+
+void SceneTriggerWidget::setSwitchData(SceneTrigger *s)
+{
+	switchData = s;
+}
+
+void SceneTriggerWidget::swapSwitchData(SceneTriggerWidget *s1,
+					SceneTriggerWidget *s2)
+{
+	SwitchWidget::swapSwitchData(s1, s2);
+
+	SceneTrigger *t = s1->getSwitchData();
+	s1->setSwitchData(s2->getSwitchData());
+	s2->setSwitchData(t);
+}
+
+void SceneTriggerWidget::TriggerTypeChanged(int index)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->triggerType = static_cast<sceneTriggerType>(index);
+}
+
+void SceneTriggerWidget::TriggerActionChanged(int index)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	{
+		std::lock_guard<std::mutex> lock(switcher->m);
+		switchData->triggerAction =
+			static_cast<sceneTriggerAction>(index);
+	}
+
+	if (switchData->triggerAction == sceneTriggerAction::MUTE_SOURCE) {
+		audioSources->show();
+	} else {
+		audioSources->hide();
+	}
+}
+
+void SceneTriggerWidget::DurationChanged(double dur)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->duration = dur;
+}
+
+void SceneTriggerWidget::AudioSourceChanged(const QString &text)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->audioSource = GetWeakSourceByQString(text);
+}

src/switch-audio.cpp

@@ -1,214 +1,183 @@
+#include <float.h>
+
 #include "headers/advanced-scene-switcher.hpp"
 #include "headers/volume-control.hpp"
+#include "headers/utility.hpp"
 
-void SceneSwitcher::on_audioSwitches_currentRowChanged(int idx)
+bool AudioSwitch::pause = false;
+static QMetaObject::Connection addPulse;
+
+void AdvSceneSwitcher::on_audioAdd_clicked()
 {
-	if (loading)
-		return;
-	if (idx == -1)
-		return;
-
-	QListWidgetItem *item = ui->audioSwitches->item(idx);
-
-	QString audioScenestr = item->data(Qt::UserRole).toString();
-
 	std::lock_guard<std::mutex> lock(switcher->m);
-	for (auto &s : switcher->audioSwitches) {
-		if (audioScenestr.compare(s.audioSwitchStr.c_str()) == 0) {
-			QString sceneName = GetWeakSourceName(s.scene).c_str();
-			QString audioSrouceName =
-				GetWeakSourceName(s.audioSource).c_str();
-			QString transitionName =
-				GetWeakSourceName(s.transition).c_str();
-			ui->audioScenes->setCurrentText(sceneName);
-			ui->audioTransitions->setCurrentText(transitionName);
-			ui->audioSources->setCurrentText(audioSrouceName);
-			ui->audioVolumeThreshold->setValue(s.volumeThreshold);
-			volMeter->GetSlider()->setValue(s.volumeThreshold);
-			break;
-		}
-	}
+	switcher->audioSwitches.emplace_back();
+
+	AudioSwitchWidget *sw =
+		new AudioSwitchWidget(this, &switcher->audioSwitches.back());
+
+	listAddClicked(ui->audioSwitches, sw, ui->audioAdd, &addPulse);
+
+	ui->audioHelp->setVisible(false);
 }
 
-void SceneSwitcher::on_audioSources_currentTextChanged(const QString &text)
-{
-	SetAudioVolumeMeter(text);
-}
-
-void SceneSwitcher::SetAudioVolumeMeter(const QString &name)
-{
-	obs_source_t *soruce =
-		obs_get_source_by_name(name.toUtf8().constData());
-	if (!soruce) {
-		return;
-	}
-
-	if (volMeter) {
-		ui->audioControlLayout->removeWidget(volMeter);
-		delete volMeter;
-	}
-
-	volMeter = new VolControl(soruce);
-	ui->audioControlLayout->addWidget(volMeter);
-	obs_source_release(soruce);
-
-	QWidget::connect(volMeter->GetSlider(), SIGNAL(valueChanged(int)),
-			 ui->audioVolumeThreshold, SLOT(setValue(int)));
-	QWidget::connect(ui->audioVolumeThreshold, SIGNAL(valueChanged(int)),
-			 volMeter->GetSlider(), SLOT(setValue(int)));
-}
-
-int SceneSwitcher::audioFindByData(const QString &source, const int &volume)
-{
-	QRegExp rx(MakeAudioSwitchName(QStringLiteral(".*"),
-				       QStringLiteral(".*"), source, volume));
-	int count = ui->audioSwitches->count();
-
-	for (int i = 0; i < count; i++) {
-		QListWidgetItem *item = ui->audioSwitches->item(i);
-		QString str = item->data(Qt::UserRole).toString();
-
-		if (rx.exactMatch(str))
-			return i;
-	}
-
-	return -1;
-}
-
-void SceneSwitcher::on_audioAdd_clicked()
-{
-	QString sceneName = ui->audioScenes->currentText();
-	QString transitionName = ui->audioTransitions->currentText();
-	QString audioSourceName = ui->audioSources->currentText();
-	int vol = ui->audioVolumeThreshold->value();
-
-	if (sceneName.isEmpty() || audioSourceName.isEmpty())
-		return;
-
-	OBSWeakSource source = GetWeakSourceByQString(sceneName);
-	OBSWeakSource audioSource = GetWeakSourceByQString(audioSourceName);
-	OBSWeakSource transition = GetWeakTransitionByQString(transitionName);
-
-	QString text = MakeAudioSwitchName(sceneName, transitionName,
-					   audioSourceName, vol);
-	QVariant v = QVariant::fromValue(text);
-
-	int idx = audioFindByData(audioSourceName, vol);
-
-	if (idx == -1) {
-		std::lock_guard<std::mutex> lock(switcher->m);
-		switcher->audioSwitches.emplace_back(
-			source, transition, audioSource, vol,
-			(sceneName == QString(previous_scene_name)),
-			text.toUtf8().constData());
-		QListWidgetItem *item =
-			new QListWidgetItem(text, ui->audioSwitches);
-		item->setData(Qt::UserRole, v);
-	} else {
-		QListWidgetItem *item = ui->audioSwitches->item(idx);
-		item->setText(text);
-		item->setData(Qt::UserRole, v);
-
-		{
-			std::lock_guard<std::mutex> lock(switcher->m);
-			for (auto &s : switcher->audioSwitches) {
-				if (s.audioSource == audioSource &&
-				    s.volumeThreshold == vol) {
-					s.scene = source;
-					s.transition = transition;
-					s.usePreviousScene =
-						(sceneName ==
-						 QString(previous_scene_name));
-					s.audioSwitchStr =
-						text.toUtf8().constData();
-					break;
-				}
-			}
-		}
-	}
-}
-
-void SceneSwitcher::on_audioRemove_clicked()
+void AdvSceneSwitcher::on_audioRemove_clicked()
 {
 	QListWidgetItem *item = ui->audioSwitches->currentItem();
-	if (!item)
+	if (!item) {
 		return;
-
-	std::string text =
-		item->data(Qt::UserRole).toString().toUtf8().constData();
+	}
 
 	{
 		std::lock_guard<std::mutex> lock(switcher->m);
+		int idx = ui->audioSwitches->currentRow();
 		auto &switches = switcher->audioSwitches;
-
-		for (auto it = switches.begin(); it != switches.end(); ++it) {
-			auto &s = *it;
-
-			if (s.audioSwitchStr == text) {
-				switches.erase(it);
-				break;
-			}
-		}
+		switches.erase(switches.begin() + idx);
 	}
 
 	delete item;
 }
 
-void SceneSwitcher::on_audioUp_clicked()
+void AdvSceneSwitcher::on_audioUp_clicked()
 {
 	int index = ui->audioSwitches->currentRow();
-	if (index != -1 && index != 0) {
-		ui->audioSwitches->insertItem(
-			index - 1, ui->audioSwitches->takeItem(index));
-		ui->audioSwitches->setCurrentRow(index - 1);
-
-		std::lock_guard<std::mutex> lock(switcher->m);
-
-		iter_swap(switcher->audioSwitches.begin() + index,
-			  switcher->audioSwitches.begin() + index - 1);
+	if (!listMoveUp(ui->audioSwitches)) {
+		return;
 	}
+
+	AudioSwitchWidget *s1 =
+		(AudioSwitchWidget *)ui->audioSwitches->itemWidget(
+			ui->audioSwitches->item(index));
+	AudioSwitchWidget *s2 =
+		(AudioSwitchWidget *)ui->audioSwitches->itemWidget(
+			ui->audioSwitches->item(index - 1));
+	AudioSwitchWidget::swapSwitchData(s1, s2);
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+
+	std::swap(switcher->audioSwitches[index],
+		  switcher->audioSwitches[index - 1]);
 }
 
-void SceneSwitcher::on_audioDown_clicked()
+void AdvSceneSwitcher::on_audioDown_clicked()
 {
 	int index = ui->audioSwitches->currentRow();
-	if (index != -1 && index != ui->audioSwitches->count() - 1) {
-		ui->audioSwitches->insertItem(
-			index + 1, ui->audioSwitches->takeItem(index));
-		ui->audioSwitches->setCurrentRow(index + 1);
 
-		std::lock_guard<std::mutex> lock(switcher->m);
-
-		iter_swap(switcher->audioSwitches.begin() + index,
-			  switcher->audioSwitches.begin() + index + 1);
+	if (!listMoveDown(ui->audioSwitches)) {
+		return;
 	}
+
+	AudioSwitchWidget *s1 =
+		(AudioSwitchWidget *)ui->audioSwitches->itemWidget(
+			ui->audioSwitches->item(index));
+	AudioSwitchWidget *s2 =
+		(AudioSwitchWidget *)ui->audioSwitches->itemWidget(
+			ui->audioSwitches->item(index + 1));
+	AudioSwitchWidget::swapSwitchData(s1, s2);
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+
+	std::swap(switcher->audioSwitches[index],
+		  switcher->audioSwitches[index + 1]);
+}
+
+void AdvSceneSwitcher::on_audioFallback_toggled(bool on)
+{
+	if (loading || !switcher) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switcher->audioFallback.enable = on;
+}
+
+void SwitcherData::checkAudioSwitchFallback(OBSWeakSource &scene,
+					    OBSWeakSource &transition)
+{
+	bool durationReached =
+		((unsigned long long)audioFallback.matchCount * interval) /
+			1000.0 >=
+		audioFallback.duration;
+
+	if (durationReached) {
+
+		scene = audioFallback.getScene();
+		transition = audioFallback.transition;
+
+		if (verbose) {
+			audioFallback.logMatch();
+		}
+	}
+
+	audioFallback.matchCount++;
 }
 
 void SwitcherData::checkAudioSwitch(bool &match, OBSWeakSource &scene,
 				    OBSWeakSource &transition)
 {
-	if (audioSwitches.size() == 0)
+	if (AudioSwitch::pause) {
 		return;
+	}
+
+	bool fallbackChecked = false; // false if only one or no match
 
 	for (AudioSwitch &s : audioSwitches) {
+		if (!s.initialized()) {
+			continue;
+		}
+
 		obs_source_t *as = obs_weak_source_get_source(s.audioSource);
 		bool audioActive = obs_source_active(as);
 		obs_source_release(as);
 
 		// peak will have a value from -60 db to 0 db
-		bool volumeThresholdreached = (s.peak + 60) * 1.7 >
-					      s.volumeThreshold;
+		bool volumeThresholdreached = false;
 
-		if (volumeThresholdreached && audioActive) {
-			scene = (s.usePreviousScene) ? previousScene : s.scene;
+		if (s.condition == ABOVE) {
+			volumeThresholdreached = ((double)s.peak + 60) * 1.7 >
+						 s.volumeThreshold;
+		} else {
+			volumeThresholdreached = ((double)s.peak + 60) * 1.7 <
+						 s.volumeThreshold;
+		}
+
+		// Reset for next check
+		s.peak = -FLT_MAX;
+
+		if (volumeThresholdreached) {
+			s.matchCount++;
+		} else {
+			s.matchCount = 0;
+		}
+
+		bool durationReached =
+			((unsigned long long)s.matchCount * interval) /
+				1000.0 >=
+			s.duration;
+
+		if (volumeThresholdreached && durationReached && audioActive) {
+			if (match) {
+				checkAudioSwitchFallback(scene, transition);
+				fallbackChecked = true;
+				break;
+			}
+
+			scene = s.getScene();
 			transition = s.transition;
 			match = true;
 
-			if (verbose)
+			if (verbose) {
 				s.logMatch();
-			break;
+			}
+
+			if (!audioFallback.enable) {
+				break;
+			}
 		}
 	}
+
+	if (!fallbackChecked) {
+		audioFallback.matchCount = 0;
+	}
 }
 
 void SwitcherData::saveAudioSwitches(obs_data_t *obj)
@@ -217,38 +186,15 @@ void SwitcherData::saveAudioSwitches(obs_data_t *obj)
 	for (AudioSwitch &s : switcher->audioSwitches) {
 		obs_data_t *array_obj = obs_data_create();
 
-		obs_source_t *sceneSource = obs_weak_source_get_source(s.scene);
-		obs_source_t *transition =
-			obs_weak_source_get_source(s.transition);
-		obs_source_t *audioSrouce =
-			obs_weak_source_get_source(s.audioSource);
-		if ((s.usePreviousScene || sceneSource) && transition) {
-			const char *sceneName =
-				obs_source_get_name(sceneSource);
-			const char *transitionName =
-				obs_source_get_name(transition);
-			const char *audioSourceName =
-				obs_source_get_name(audioSrouce);
-			obs_data_set_string(array_obj, "scene",
-					    s.usePreviousScene
-						    ? previous_scene_name
-						    : sceneName);
-			obs_data_set_string(array_obj, "transition",
-					    transitionName);
-			obs_data_set_string(array_obj, "audioSource",
-					    audioSourceName);
-			obs_data_set_int(array_obj, "volume",
-					 s.volumeThreshold);
-			obs_data_array_push_back(audioArray, array_obj);
-		}
-		obs_source_release(sceneSource);
-		obs_source_release(transition);
-		obs_source_release(audioSrouce);
+		s.save(array_obj);
+		obs_data_array_push_back(audioArray, array_obj);
 
 		obs_data_release(array_obj);
 	}
 	obs_data_set_array(obj, "audioSwitches", audioArray);
 	obs_data_array_release(audioArray);
+
+	audioFallback.save(obj);
 }
 
 void SwitcherData::loadAudioSwitches(obs_data_t *obj)
@@ -261,75 +207,436 @@ void SwitcherData::loadAudioSwitches(obs_data_t *obj)
 	for (size_t i = 0; i < count; i++) {
 		obs_data_t *array_obj = obs_data_array_item(audioArray, i);
 
-		const char *scene = obs_data_get_string(array_obj, "scene");
-		const char *transition =
-			obs_data_get_string(array_obj, "transition");
-		const char *audioSource =
-			obs_data_get_string(array_obj, "audioSource");
-		int vol = obs_data_get_int(array_obj, "volume");
-
-		std::string audioSwitchStr =
-			MakeAudioSwitchName(scene, transition, audioSource, vol)
-				.toUtf8()
-				.constData();
-
-		switcher->audioSwitches.emplace_back(
-			GetWeakSourceByName(scene),
-			GetWeakTransitionByName(transition),
-			GetWeakSourceByName(audioSource), vol,
-			(strcmp(scene, previous_scene_name) == 0),
-			audioSwitchStr);
+		switcher->audioSwitches.emplace_back();
+		audioSwitches.back().load(array_obj);
 
 		obs_data_release(array_obj);
 	}
 	obs_data_array_release(audioArray);
+
+	audioFallback.load(obj);
 }
 
-void SceneSwitcher::setupAudioTab()
+void AdvSceneSwitcher::setupAudioTab()
 {
-	populateSceneSelection(ui->audioScenes, true);
-	populateTransitionSelection(ui->audioTransitions);
-
-	auto sourceEnum = [](void *data, obs_source_t *source) -> bool /* -- */
-	{
-		QComboBox *combo = reinterpret_cast<QComboBox *>(data);
-		uint32_t flags = obs_source_get_output_flags(source);
-
-		if ((flags & OBS_SOURCE_AUDIO) != 0) {
-			const char *name = obs_source_get_name(source);
-			combo->addItem(name);
-		}
-		return true;
-	};
-
-	obs_enum_sources(sourceEnum, ui->audioSources);
-
 	for (auto &s : switcher->audioSwitches) {
-		std::string sceneName = (s.usePreviousScene)
-						? previous_scene_name
-						: GetWeakSourceName(s.scene);
-		std::string transitionName = GetWeakSourceName(s.transition);
-		std::string audioSourceName = GetWeakSourceName(s.audioSource);
-		QString listText = MakeAudioSwitchName(sceneName.c_str(),
-						       transitionName.c_str(),
-						       audioSourceName.c_str(),
-						       s.volumeThreshold);
+		QListWidgetItem *item;
+		item = new QListWidgetItem(ui->audioSwitches);
+		ui->audioSwitches->addItem(item);
+		AudioSwitchWidget *sw = new AudioSwitchWidget(this, &s);
+		item->setSizeHint(sw->minimumSizeHint());
+		ui->audioSwitches->setItemWidget(item, sw);
+	}
 
-		QListWidgetItem *item =
-			new QListWidgetItem(listText, ui->audioSwitches);
-		item->setData(Qt::UserRole, listText);
+	if (switcher->audioSwitches.size() == 0) {
+		addPulse = PulseWidget(ui->audioAdd, QColor(Qt::green));
+		ui->audioHelp->setVisible(true);
+	} else {
+		ui->audioHelp->setVisible(false);
+	}
+
+	AudioSwitchFallbackWidget *fb =
+		new AudioSwitchFallbackWidget(this, &switcher->audioFallback);
+	ui->audioFallbackLayout->addWidget(fb);
+	ui->audioFallback->setChecked(switcher->audioFallback.enable);
+}
+
+void AudioSwitch::setVolumeLevel(void *data,
+				 const float magnitude[MAX_AUDIO_CHANNELS],
+				 const float peak[MAX_AUDIO_CHANNELS],
+				 const float inputPeak[MAX_AUDIO_CHANNELS])
+{
+	UNUSED_PARAMETER(magnitude);
+	UNUSED_PARAMETER(inputPeak);
+	AudioSwitch *s = static_cast<AudioSwitch *>(data);
+
+	for (int i = 1; i < MAX_AUDIO_CHANNELS; i++) {
+		if (peak[i] > s->peak) {
+			s->peak = peak[i];
+		}
 	}
 }
 
-static inline QString MakeAudioSwitchName(const QString &scene,
-					  const QString &transition,
-					  const QString &audioSrouce,
-					  const int &volume)
+obs_volmeter_t *AddVolmeterToSource(AudioSwitch *entry, obs_weak_source *source)
 {
-	QString switchName = QStringLiteral("When volume of ") + audioSrouce +
-			     QStringLiteral(" is above ") +
-			     QString::number(volume) +
-			     QStringLiteral("% switch to ") + scene +
-			     QStringLiteral(" using ") + transition;
-	return switchName;
+	obs_volmeter_t *volmeter = obs_volmeter_create(OBS_FADER_LOG);
+	obs_volmeter_add_callback(volmeter, AudioSwitch::setVolumeLevel, entry);
+	obs_source_t *as = obs_weak_source_get_source(source);
+	if (!obs_volmeter_attach_source(volmeter, as)) {
+		const char *name = obs_source_get_name(as);
+		blog(LOG_WARNING, "failed to attach volmeter to source %s",
+		     name);
+	}
+	obs_source_release(as);
+
+	return volmeter;
+}
+
+void AudioSwitch::resetVolmeter()
+{
+	obs_volmeter_remove_callback(volmeter, setVolumeLevel, this);
+	obs_volmeter_destroy(volmeter);
+
+	volmeter = AddVolmeterToSource(this, audioSource);
+}
+
+bool AudioSwitch::initialized()
+{
+	return SceneSwitcherEntry::initialized() && audioSource;
+}
+
+bool AudioSwitch::valid()
+{
+	return !initialized() ||
+	       (SceneSwitcherEntry::valid() && WeakSourceValid(audioSource));
+}
+
+void AudioSwitch::save(obs_data_t *obj)
+{
+	SceneSwitcherEntry::save(obj);
+
+	obs_data_set_string(obj, "audioSource",
+			    GetWeakSourceName(audioSource).c_str());
+
+	obs_data_set_int(obj, "volume", volumeThreshold);
+	obs_data_set_int(obj, "condition", condition);
+	obs_data_set_double(obj, "duration", duration);
+}
+
+// To be removed in future version
+bool loadOldAudio(obs_data_t *obj, AudioSwitch *s)
+{
+	if (!s) {
+		return false;
+	}
+
+	const char *scene = obs_data_get_string(obj, "scene");
+
+	if (strcmp(scene, "") == 0) {
+		return false;
+	}
+
+	s->scene = GetWeakSourceByName(scene);
+
+	const char *transition = obs_data_get_string(obj, "transition");
+	s->transition = GetWeakTransitionByName(transition);
+
+	const char *audioSource = obs_data_get_string(obj, "audioSource");
+	s->audioSource = GetWeakSourceByName(audioSource);
+
+	s->volumeThreshold = obs_data_get_int(obj, "volume");
+	s->condition = (audioCondition)obs_data_get_int(obj, "condition");
+	s->duration = obs_data_get_double(obj, "duration");
+	s->usePreviousScene = strcmp(scene, previous_scene_name) == 0;
+
+	return true;
+}
+
+void AudioSwitch::load(obs_data_t *obj)
+{
+	if (loadOldAudio(obj, this)) {
+		return;
+	}
+
+	SceneSwitcherEntry::load(obj);
+
+	const char *audioSourceName = obs_data_get_string(obj, "audioSource");
+	audioSource = GetWeakSourceByName(audioSourceName);
+
+	volumeThreshold = obs_data_get_int(obj, "volume");
+	condition = (audioCondition)obs_data_get_int(obj, "condition");
+	duration = obs_data_get_double(obj, "duration");
+
+	volmeter = AddVolmeterToSource(this, audioSource);
+}
+
+void AudioSwitchFallback::save(obs_data_t *obj)
+{
+	SceneSwitcherEntry::save(obj, "audioFallbackTargetType",
+				 "audioFallbackScene",
+				 "audioFallbackTransition");
+
+	obs_data_set_bool(obj, "audioFallbackEnable", enable);
+	obs_data_set_double(obj, "audioFallbackDuration", duration);
+}
+
+void AudioSwitchFallback::load(obs_data_t *obj)
+{
+	SceneSwitcherEntry::load(obj, "audioFallbackTargetType",
+				 "audioFallbackScene",
+				 "audioFallbackTransition");
+
+	enable = obs_data_get_bool(obj, "audioFallbackEnable");
+	duration = obs_data_get_double(obj, "audioFallbackDuration");
+}
+
+AudioSwitch::AudioSwitch(const AudioSwitch &other)
+	: SceneSwitcherEntry(other.targetType, other.group, other.scene,
+			     other.transition, other.usePreviousScene),
+	  audioSource(other.audioSource),
+	  volumeThreshold(other.volumeThreshold),
+	  condition(other.condition),
+	  duration(other.duration)
+{
+	volmeter = AddVolmeterToSource(this, other.audioSource);
+}
+
+AudioSwitch::AudioSwitch(AudioSwitch &&other)
+	: SceneSwitcherEntry(other.targetType, other.group, other.scene,
+			     other.transition, other.usePreviousScene),
+	  audioSource(other.audioSource),
+	  volumeThreshold(other.volumeThreshold),
+	  condition(other.condition),
+	  duration(other.duration),
+	  volmeter(other.volmeter)
+{
+	other.volmeter = nullptr;
+}
+
+AudioSwitch::~AudioSwitch()
+{
+	obs_volmeter_remove_callback(volmeter, setVolumeLevel, this);
+	obs_volmeter_destroy(volmeter);
+}
+
+AudioSwitch &AudioSwitch::operator=(const AudioSwitch &other)
+{
+	AudioSwitch t(other);
+	swap(*this, t);
+	return *this = AudioSwitch(other);
+}
+
+AudioSwitch &AudioSwitch::operator=(AudioSwitch &&other) noexcept
+{
+	if (this == &other) {
+		return *this;
+	}
+
+	swap(*this, other);
+
+	obs_volmeter_remove_callback(other.volmeter, setVolumeLevel, this);
+	obs_volmeter_destroy(other.volmeter);
+	other.volmeter = nullptr;
+
+	return *this;
+}
+
+void swap(AudioSwitch &first, AudioSwitch &second)
+{
+	std::swap(first.targetType, second.targetType);
+	std::swap(first.group, second.group);
+	std::swap(first.scene, second.scene);
+	std::swap(first.transition, second.transition);
+	std::swap(first.usePreviousScene, second.usePreviousScene);
+	std::swap(first.audioSource, second.audioSource);
+	std::swap(first.volumeThreshold, second.volumeThreshold);
+	std::swap(first.condition, second.condition);
+	std::swap(first.duration, second.duration);
+	std::swap(first.peak, second.peak);
+	std::swap(first.volmeter, second.volmeter);
+	first.resetVolmeter();
+	second.resetVolmeter();
+}
+
+void populateConditionSelection(QComboBox *list)
+{
+	list->addItem(
+		obs_module_text("AdvSceneSwitcher.audioTab.condition.above"));
+	list->addItem(
+		obs_module_text("AdvSceneSwitcher.audioTab.condition.below"));
+}
+
+AudioSwitchWidget::AudioSwitchWidget(QWidget *parent, AudioSwitch *s)
+	: SwitchWidget(parent, s, true, true)
+{
+	audioSources = new QComboBox();
+	condition = new QComboBox();
+	audioVolumeThreshold = new QSpinBox();
+	duration = new QDoubleSpinBox();
+
+	obs_source_t *source = nullptr;
+	if (s) {
+		source = obs_weak_source_get_source(s->audioSource);
+	}
+	volMeter = new VolControl(source);
+	obs_source_release(source);
+
+	audioVolumeThreshold->setSuffix("%");
+	audioVolumeThreshold->setMaximum(100);
+	audioVolumeThreshold->setMinimum(0);
+
+	duration->setMinimum(0.0);
+	duration->setMaximum(99.000000);
+	duration->setSuffix("s");
+
+	QWidget::connect(volMeter->GetSlider(), SIGNAL(valueChanged(int)),
+			 audioVolumeThreshold, SLOT(setValue(int)));
+	QWidget::connect(audioVolumeThreshold, SIGNAL(valueChanged(int)),
+			 volMeter->GetSlider(), SLOT(setValue(int)));
+	QWidget::connect(audioVolumeThreshold, SIGNAL(valueChanged(int)), this,
+			 SLOT(VolumeThresholdChanged(int)));
+	QWidget::connect(condition, SIGNAL(currentIndexChanged(int)), this,
+			 SLOT(ConditionChanged(int)));
+	QWidget::connect(duration, SIGNAL(valueChanged(double)), this,
+			 SLOT(DurationChanged(double)));
+	QWidget::connect(audioSources,
+			 SIGNAL(currentTextChanged(const QString &)), this,
+			 SLOT(SourceChanged(const QString &)));
+
+	AdvSceneSwitcher::populateAudioSelection(audioSources);
+	populateConditionSelection(condition);
+
+	if (s) {
+		audioSources->setCurrentText(
+			GetWeakSourceName(s->audioSource).c_str());
+		audioVolumeThreshold->setValue(s->volumeThreshold);
+		condition->setCurrentIndex(s->condition);
+		duration->setValue(s->duration);
+	}
+
+	QHBoxLayout *switchLayout = new QHBoxLayout;
+	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
+		{"{{audioSources}}", audioSources},
+		{"{{volumeWidget}}", audioVolumeThreshold},
+		{"{{condition}}", condition},
+		{"{{duration}}", duration},
+		{"{{scenes}}", scenes},
+		{"{{transitions}}", transitions}};
+	placeWidgets(obs_module_text("AdvSceneSwitcher.audioTab.entry"),
+		     switchLayout, widgetPlaceholders);
+
+	QVBoxLayout *mainLayout = new QVBoxLayout;
+
+	mainLayout->addLayout(switchLayout);
+	mainLayout->addWidget(volMeter);
+
+	setLayout(mainLayout);
+
+	switchData = s;
+
+	loading = false;
+}
+
+AudioSwitch *AudioSwitchWidget::getSwitchData()
+{
+	return switchData;
+}
+
+void AudioSwitchWidget::setSwitchData(AudioSwitch *s)
+{
+	switchData = s;
+}
+
+void AudioSwitchWidget::swapSwitchData(AudioSwitchWidget *s1,
+				       AudioSwitchWidget *s2)
+{
+	SwitchWidget::swapSwitchData(s1, s2);
+
+	AudioSwitch *t = s1->getSwitchData();
+	s1->setSwitchData(s2->getSwitchData());
+	s2->setSwitchData(t);
+}
+
+void AudioSwitchWidget::UpdateVolmeterSource()
+{
+	delete volMeter;
+	obs_source_t *soruce =
+		obs_weak_source_get_source(switchData->audioSource);
+	volMeter = new VolControl(soruce);
+	obs_source_release(soruce);
+
+	QLayout *layout = this->layout();
+	layout->addWidget(volMeter);
+
+	QWidget::connect(volMeter->GetSlider(), SIGNAL(valueChanged(int)),
+			 audioVolumeThreshold, SLOT(setValue(int)));
+	QWidget::connect(audioVolumeThreshold, SIGNAL(valueChanged(int)),
+			 volMeter->GetSlider(), SLOT(setValue(int)));
+
+	// Slider will default to 0 so set it manually once
+	volMeter->GetSlider()->setValue(switchData->volumeThreshold);
+}
+
+void AudioSwitchWidget::SourceChanged(const QString &text)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->audioSource = GetWeakSourceByQString(text);
+	switchData->resetVolmeter();
+	UpdateVolmeterSource();
+}
+
+void AudioSwitchWidget::VolumeThresholdChanged(int vol)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->volumeThreshold = vol;
+}
+
+void AudioSwitchWidget::ConditionChanged(int cond)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->condition = (audioCondition)cond;
+}
+
+void AudioSwitchWidget::DurationChanged(double dur)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->duration = dur;
+}
+
+AudioSwitchFallbackWidget::AudioSwitchFallbackWidget(QWidget *parent,
+						     AudioSwitchFallback *s)
+	: SwitchWidget(parent, s, true, true)
+{
+	duration = new QDoubleSpinBox();
+
+	duration->setMinimum(0.0);
+	duration->setMaximum(99.000000);
+	duration->setSuffix("s");
+
+	QWidget::connect(duration, SIGNAL(valueChanged(double)), this,
+			 SLOT(DurationChanged(double)));
+
+	if (s) {
+		duration->setValue(s->duration);
+	}
+
+	QHBoxLayout *mainLayout = new QHBoxLayout;
+	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
+		{"{{scenes}}", scenes},
+		{"{{duration}}", duration},
+		{"{{transitions}}", transitions}};
+	placeWidgets(
+		obs_module_text("AdvSceneSwitcher.audioTab.multiMatchfallback"),
+		mainLayout, widgetPlaceholders);
+	setLayout(mainLayout);
+
+	switchData = s;
+
+	loading = false;
+}
+
+void AudioSwitchFallbackWidget::DurationChanged(double dur)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->duration = dur;
 }

src/switch-executable.cpp

@@ -1,151 +1,89 @@
 #include "headers/advanced-scene-switcher.hpp"
+#include "headers/utility.hpp"
 
-int SceneSwitcher::executableFindByData(const QString &exe)
+bool ExecutableSwitch::pause = false;
+static QMetaObject::Connection addPulse;
+
+void AdvSceneSwitcher::on_executableAdd_clicked()
 {
-	int count = ui->executables->count();
-
-	for (int i = 0; i < count; i++) {
-		QListWidgetItem *item = ui->executables->item(i);
-		QString itemExe = item->data(Qt::UserRole).toString();
-
-		if (itemExe == exe)
-			return i;
-	}
-
-	return -1;
-}
-
-void SceneSwitcher::on_executables_currentRowChanged(int idx)
-{
-	if (loading)
-		return;
-	if (idx == -1)
-		return;
-
-	QListWidgetItem *item = ui->executables->item(idx);
-
-	QString exec = item->data(Qt::UserRole).toString();
-
 	std::lock_guard<std::mutex> lock(switcher->m);
-	for (auto &s : switcher->executableSwitches) {
-		if (exec.compare(s.exe) == 0) {
-			QString sceneName = GetWeakSourceName(s.scene).c_str();
-			QString transitionName =
-				GetWeakSourceName(s.transition).c_str();
-			ui->executableScenes->setCurrentText(sceneName);
-			ui->executable->setCurrentText(exec);
-			ui->executableTransitions->setCurrentText(
-				transitionName);
-			ui->requiresFocusCheckBox->setChecked(s.inFocus);
-			break;
-		}
-	}
+	switcher->executableSwitches.emplace_back();
+
+	listAddClicked(ui->executables,
+		       new ExecutableSwitchWidget(
+			       this, &switcher->executableSwitches.back()),
+		       ui->executableAdd, &addPulse);
+
+	ui->exeHelp->setVisible(false);
 }
 
-void SceneSwitcher::on_executableUp_clicked()
-{
-	int index = ui->executables->currentRow();
-	if (index != -1 && index != 0) {
-		ui->executables->insertItem(index - 1,
-					    ui->executables->takeItem(index));
-		ui->executables->setCurrentRow(index - 1);
-
-		std::lock_guard<std::mutex> lock(switcher->m);
-
-		iter_swap(switcher->executableSwitches.begin() + index,
-			  switcher->executableSwitches.begin() + index - 1);
-	}
-}
-
-void SceneSwitcher::on_executableDown_clicked()
-{
-	int index = ui->executables->currentRow();
-	if (index != -1 && index != ui->executables->count() - 1) {
-		ui->executables->insertItem(index + 1,
-					    ui->executables->takeItem(index));
-		ui->executables->setCurrentRow(index + 1);
-
-		std::lock_guard<std::mutex> lock(switcher->m);
-
-		iter_swap(switcher->executableSwitches.begin() + index,
-			  switcher->executableSwitches.begin() + index + 1);
-	}
-}
-
-void SceneSwitcher::on_executableAdd_clicked()
-{
-	QString sceneName = ui->executableScenes->currentText();
-	QString exeName = ui->executable->currentText();
-	QString transitionName = ui->executableTransitions->currentText();
-	bool inFocus = ui->requiresFocusCheckBox->isChecked();
-
-	if (exeName.isEmpty() || sceneName.isEmpty())
-		return;
-
-	OBSWeakSource source = GetWeakSourceByQString(sceneName);
-	OBSWeakSource transition = GetWeakTransitionByQString(transitionName);
-	QVariant v = QVariant::fromValue(exeName);
-
-	QString text = MakeSwitchNameExecutable(sceneName, exeName,
-						transitionName, inFocus);
-
-	int idx = executableFindByData(exeName);
-
-	if (idx == -1) {
-		std::lock_guard<std::mutex> lock(switcher->m);
-		switcher->executableSwitches.emplace_back(
-			source, transition, exeName.toUtf8().constData(),
-			inFocus);
-
-		QListWidgetItem *item =
-			new QListWidgetItem(text, ui->executables);
-		item->setData(Qt::UserRole, v);
-	} else {
-		QListWidgetItem *item = ui->executables->item(idx);
-		item->setText(text);
-
-		{
-			std::lock_guard<std::mutex> lock(switcher->m);
-			for (auto &s : switcher->executableSwitches) {
-				if (s.exe == exeName) {
-					s.scene = source;
-					s.transition = transition;
-					s.inFocus = inFocus;
-					break;
-				}
-			}
-		}
-	}
-}
-
-void SceneSwitcher::on_executableRemove_clicked()
+void AdvSceneSwitcher::on_executableRemove_clicked()
 {
 	QListWidgetItem *item = ui->executables->currentItem();
-	if (!item)
+	if (!item) {
 		return;
-
-	QString exe = item->data(Qt::UserRole).toString();
+	}
 
 	{
 		std::lock_guard<std::mutex> lock(switcher->m);
+		int idx = ui->executables->currentRow();
 		auto &switches = switcher->executableSwitches;
-
-		for (auto it = switches.begin(); it != switches.end(); ++it) {
-			auto &s = *it;
-
-			if (s.exe == exe) {
-				switches.erase(it);
-				break;
-			}
-		}
+		switches.erase(switches.begin() + idx);
 	}
 
 	delete item;
 }
 
+void AdvSceneSwitcher::on_executableUp_clicked()
+{
+	int index = ui->executables->currentRow();
+	if (!listMoveUp(ui->executables)) {
+		return;
+	}
+
+	ExecutableSwitchWidget *s1 =
+		(ExecutableSwitchWidget *)ui->executables->itemWidget(
+			ui->executables->item(index));
+	ExecutableSwitchWidget *s2 =
+		(ExecutableSwitchWidget *)ui->executables->itemWidget(
+			ui->executables->item(index - 1));
+	ExecutableSwitchWidget::swapSwitchData(s1, s2);
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+
+	std::swap(switcher->executableSwitches[index],
+		  switcher->executableSwitches[index - 1]);
+}
+
+void AdvSceneSwitcher::on_executableDown_clicked()
+{
+	int index = ui->executables->currentRow();
+
+	if (!listMoveDown(ui->executables)) {
+		return;
+	}
+
+	ExecutableSwitchWidget *s1 =
+		(ExecutableSwitchWidget *)ui->executables->itemWidget(
+			ui->executables->item(index));
+	ExecutableSwitchWidget *s2 =
+		(ExecutableSwitchWidget *)ui->executables->itemWidget(
+			ui->executables->item(index + 1));
+	ExecutableSwitchWidget::swapSwitchData(s1, s2);
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+
+	std::swap(switcher->executableSwitches[index],
+		  switcher->executableSwitches[index + 1]);
+}
+
 void SwitcherData::checkExeSwitch(bool &match, OBSWeakSource &scene,
 				  OBSWeakSource &transition)
 {
+	if (executableSwitches.size() == 0 || ExecutableSwitch::pause) {
+		return;
+	}
+
 	std::string title;
 	QStringList runningProcesses;
 	bool ignored = false;
@@ -170,14 +108,16 @@ void SwitcherData::checkExeSwitch(bool &match, OBSWeakSource &scene,
 
 	// Check for match
 	GetProcessList(runningProcesses);
-	for (ExecutableSceneSwitch &s : executableSwitches) {
-		// True if executable switch is running (direct)
+	for (ExecutableSwitch &s : executableSwitches) {
+		if (!s.initialized()) {
+			continue;
+		}
+
 		bool equals = runningProcesses.contains(s.exe);
-		// True if executable switch is running (regex)
 		bool matches = (runningProcesses.indexOf(
 					QRegularExpression(s.exe)) != -1);
-		// True if focus is disabled OR switch is focused
 		bool focus = (!s.inFocus || isInFocus(s.exe));
+
 		// True if current window is ignored AND switch equals OR matches last window
 		bool ignore =
 			(ignored && (title == s.exe.toStdString() ||
@@ -186,11 +126,12 @@ void SwitcherData::checkExeSwitch(bool &match, OBSWeakSource &scene,
 
 		if ((equals || matches) && (focus || ignore)) {
 			match = true;
-			scene = s.scene;
+			scene = s.getScene();
 			transition = s.transition;
 
-			if (verbose)
+			if (verbose) {
 				s.logMatch();
+			}
 			break;
 		}
 	}
@@ -199,27 +140,11 @@ void SwitcherData::checkExeSwitch(bool &match, OBSWeakSource &scene,
 void SwitcherData::saveExecutableSwitches(obs_data_t *obj)
 {
 	obs_data_array_t *executableArray = obs_data_array_create();
-	for (ExecutableSceneSwitch &s : switcher->executableSwitches) {
+	for (ExecutableSwitch &s : switcher->executableSwitches) {
 		obs_data_t *array_obj = obs_data_create();
 
-		obs_source_t *source = obs_weak_source_get_source(s.scene);
-		obs_source_t *transition =
-			obs_weak_source_get_source(s.transition);
-
-		if (source && transition) {
-			const char *sceneName = obs_source_get_name(source);
-			const char *transitionName =
-				obs_source_get_name(transition);
-			obs_data_set_string(array_obj, "scene", sceneName);
-			obs_data_set_string(array_obj, "transition",
-					    transitionName);
-			obs_data_set_string(array_obj, "exefile",
-					    s.exe.toUtf8());
-			obs_data_set_bool(array_obj, "infocus", s.inFocus);
-			obs_data_array_push_back(executableArray, array_obj);
-			obs_source_release(source);
-			obs_source_release(transition);
-		}
+		s.save(array_obj);
+		obs_data_array_push_back(executableArray, array_obj);
 
 		obs_data_release(array_obj);
 	}
@@ -238,54 +163,153 @@ void SwitcherData::loadExecutableSwitches(obs_data_t *obj)
 	for (size_t i = 0; i < count; i++) {
 		obs_data_t *array_obj = obs_data_array_item(executableArray, i);
 
-		const char *scene = obs_data_get_string(array_obj, "scene");
-		const char *transition =
-			obs_data_get_string(array_obj, "transition");
-		const char *exe = obs_data_get_string(array_obj, "exefile");
-		bool infocus = obs_data_get_bool(array_obj, "infocus");
-
-		switcher->executableSwitches.emplace_back(
-			GetWeakSourceByName(scene),
-			GetWeakTransitionByName(transition), exe, infocus);
+		switcher->executableSwitches.emplace_back();
+		executableSwitches.back().load(array_obj);
 
 		obs_data_release(array_obj);
 	}
 	obs_data_array_release(executableArray);
 }
 
-void SceneSwitcher::setupExecutableTab()
+void AdvSceneSwitcher::setupExecutableTab()
 {
-	populateSceneSelection(ui->executableScenes, false);
-	populateTransitionSelection(ui->executableTransitions);
-
-	QStringList processes;
-	GetProcessList(processes);
-	for (QString &process : processes)
-		ui->executable->addItem(process);
-
 	for (auto &s : switcher->executableSwitches) {
-		std::string sceneName = GetWeakSourceName(s.scene);
-		std::string transitionName = GetWeakSourceName(s.transition);
-		QString text = MakeSwitchNameExecutable(sceneName.c_str(),
-							s.exe,
-							transitionName.c_str(),
-							s.inFocus);
+		QListWidgetItem *item;
+		item = new QListWidgetItem(ui->executables);
+		ui->executables->addItem(item);
+		ExecutableSwitchWidget *sw =
+			new ExecutableSwitchWidget(this, &s);
+		item->setSizeHint(sw->minimumSizeHint());
+		ui->executables->setItemWidget(item, sw);
+	}
 
-		QListWidgetItem *item =
-			new QListWidgetItem(text, ui->executables);
-		item->setData(Qt::UserRole, s.exe);
+	if (switcher->executableSwitches.size() == 0) {
+		addPulse = PulseWidget(ui->executableAdd, QColor(Qt::green));
+		ui->exeHelp->setVisible(true);
+	} else {
+		ui->exeHelp->setVisible(false);
 	}
 }
 
-static inline QString MakeSwitchNameExecutable(const QString &scene,
-					       const QString &value,
-					       const QString &transition,
-					       bool inFocus)
+void ExecutableSwitch::save(obs_data_t *obj)
 {
-	if (!inFocus)
-		return QStringLiteral("[") + scene + QStringLiteral(", ") +
-		       transition + QStringLiteral("]: ") + value;
-	return QStringLiteral("[") + scene + QStringLiteral(", ") + transition +
-	       QStringLiteral("]: ") + value +
-	       QStringLiteral(" (only if focused)");
+	SceneSwitcherEntry::save(obj);
+
+	obs_data_set_string(obj, "exefile", exe.toUtf8());
+	obs_data_set_bool(obj, "infocus", inFocus);
+}
+
+// To be removed in future version
+bool loadOldExe(obs_data_t *obj, ExecutableSwitch *s)
+{
+	if (!s) {
+		return false;
+	}
+
+	const char *scene = obs_data_get_string(obj, "scene");
+
+	if (strcmp(scene, "") == 0) {
+		return false;
+	}
+
+	s->scene = GetWeakSourceByName(scene);
+
+	const char *transition = obs_data_get_string(obj, "transition");
+	s->transition = GetWeakTransitionByName(transition);
+
+	s->exe = obs_data_get_string(obj, "exefile");
+	s->inFocus = obs_data_get_bool(obj, "infocus");
+	s->usePreviousScene = strcmp(scene, previous_scene_name) == 0;
+
+	return true;
+}
+
+void ExecutableSwitch::load(obs_data_t *obj)
+{
+	if (loadOldExe(obj, this)) {
+		return;
+	}
+
+	SceneSwitcherEntry::load(obj);
+
+	exe = obs_data_get_string(obj, "exefile");
+	inFocus = obs_data_get_bool(obj, "infocus");
+}
+
+ExecutableSwitchWidget::ExecutableSwitchWidget(QWidget *parent,
+					       ExecutableSwitch *s)
+	: SwitchWidget(parent, s, true, true)
+{
+	processes = new QComboBox();
+	requiresFocus = new QCheckBox(obs_module_text(
+		"AdvSceneSwitcher.executableTab.requiresFocus"));
+
+	QWidget::connect(processes, SIGNAL(currentTextChanged(const QString &)),
+			 this, SLOT(ProcessChanged(const QString &)));
+	QWidget::connect(requiresFocus, SIGNAL(stateChanged(int)), this,
+			 SLOT(FocusChanged(int)));
+
+	AdvSceneSwitcher::populateProcessSelection(processes);
+
+	processes->setEditable(true);
+	processes->setMaxVisibleItems(20);
+
+	if (s) {
+		processes->setCurrentText(s->exe);
+		requiresFocus->setChecked(s->inFocus);
+	}
+
+	QHBoxLayout *mainLayout = new QHBoxLayout;
+	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
+		{"{{processes}}", processes},
+		{"{{requiresFocus}}", requiresFocus},
+		{"{{scenes}}", scenes},
+		{"{{transitions}}", transitions}};
+	placeWidgets(obs_module_text("AdvSceneSwitcher.executableTab.entry"),
+		     mainLayout, widgetPlaceholders);
+	setLayout(mainLayout);
+
+	switchData = s;
+
+	loading = false;
+}
+
+ExecutableSwitch *ExecutableSwitchWidget::getSwitchData()
+{
+	return switchData;
+}
+
+void ExecutableSwitchWidget::setSwitchData(ExecutableSwitch *s)
+{
+	switchData = s;
+}
+
+void ExecutableSwitchWidget::swapSwitchData(ExecutableSwitchWidget *s1,
+					    ExecutableSwitchWidget *s2)
+{
+	SwitchWidget::swapSwitchData(s1, s2);
+
+	ExecutableSwitch *t = s1->getSwitchData();
+	s1->setSwitchData(s2->getSwitchData());
+	s2->setSwitchData(t);
+}
+
+void ExecutableSwitchWidget::ProcessChanged(const QString &text)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->exe = text;
+}
+
+void ExecutableSwitchWidget::FocusChanged(int state)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->inFocus = state;
 }

src/switch-file.cpp

@@ -1,27 +1,34 @@
 #include <QFileDialog>
 #include <QTextStream>
 #include <QDateTime>
+#include <functional>
 #include <curl/curl.h>
 
 #include "headers/advanced-scene-switcher.hpp"
 #include "headers/curl-helper.hpp"
+#include "headers/utility.hpp"
 
-#define LOCAL_FILE_IDX 0
-#define REMOTE_FILE_IDX 1
+bool FileSwitch::pause = false;
+static QMetaObject::Connection addPulse;
+static std::hash<std::string> strHash;
 
-void SceneSwitcher::on_browseButton_clicked()
+void AdvSceneSwitcher::on_browseButton_clicked()
 {
 	QString path = QFileDialog::getOpenFileName(
-		this, tr("Select a file to write to ..."), QDir::currentPath(),
-		tr("Text files (*.txt)"));
-	if (!path.isEmpty())
+		this,
+		tr(obs_module_text("AdvSceneSwitcher.fileTab.selectWrite")),
+		QDir::currentPath(),
+		tr(obs_module_text("AdvSceneSwitcher.fileTab.textFileType")));
+	if (!path.isEmpty()) {
 		ui->writePathLineEdit->setText(path);
+	}
 }
 
-void SceneSwitcher::on_readFileCheckBox_stateChanged(int state)
+void AdvSceneSwitcher::on_readFileCheckBox_stateChanged(int state)
 {
-	if (loading)
+	if (loading) {
 		return;
+	}
 
 	std::lock_guard<std::mutex> lock(switcher->m);
 	if (!state) {
@@ -35,10 +42,11 @@ void SceneSwitcher::on_readFileCheckBox_stateChanged(int state)
 	}
 }
 
-void SceneSwitcher::on_readPathLineEdit_textChanged(const QString &text)
+void AdvSceneSwitcher::on_readPathLineEdit_textChanged(const QString &text)
 {
-	if (loading)
+	if (loading) {
 		return;
+	}
 
 	std::lock_guard<std::mutex> lock(switcher->m);
 	if (text.isEmpty()) {
@@ -49,10 +57,11 @@ void SceneSwitcher::on_readPathLineEdit_textChanged(const QString &text)
 	switcher->fileIO.readPath = text.toUtf8().constData();
 }
 
-void SceneSwitcher::on_writePathLineEdit_textChanged(const QString &text)
+void AdvSceneSwitcher::on_writePathLineEdit_textChanged(const QString &text)
 {
-	if (loading)
+	if (loading) {
 		return;
+	}
 
 	std::lock_guard<std::mutex> lock(switcher->m);
 	if (text.isEmpty()) {
@@ -63,19 +72,23 @@ void SceneSwitcher::on_writePathLineEdit_textChanged(const QString &text)
 	switcher->fileIO.writePath = text.toUtf8().constData();
 }
 
-void SceneSwitcher::on_browseButton_2_clicked()
+void AdvSceneSwitcher::on_browseButton_2_clicked()
 {
 	QString path = QFileDialog::getOpenFileName(
-		this, tr("Select a file to read from ..."), QDir::currentPath(),
-		tr("Any files (*.*)"));
-	if (!path.isEmpty())
+		this,
+		tr(obs_module_text("AdvSceneSwitcher.fileTab.selectRead")),
+		QDir::currentPath(),
+		tr(obs_module_text("AdvSceneSwitcher.fileTab.anyFileType")));
+	if (!path.isEmpty()) {
 		ui->readPathLineEdit->setText(path);
+	}
 }
 
 void SwitcherData::writeSceneInfoToFile()
 {
-	if (!fileIO.writeEnabled || fileIO.writePath.empty())
+	if (!fileIO.writeEnabled || fileIO.writePath.empty()) {
 		return;
+	}
 
 	obs_source_t *currentSource = obs_frontend_get_current_scene();
 
@@ -88,11 +101,26 @@ void SwitcherData::writeSceneInfoToFile()
 	obs_source_release(currentSource);
 }
 
+void SwitcherData::writeToStatusFile(QString msg)
+{
+	if (!fileIO.writeEnabled || fileIO.writePath.empty()) {
+		return;
+	}
+
+	QFile file(QString::fromStdString(fileIO.writePath));
+	if (file.open(QIODevice::ReadWrite)) {
+		QTextStream stream(&file);
+		stream << msg << endl;
+	}
+	file.close();
+}
+
 void SwitcherData::checkSwitchInfoFromFile(bool &match, OBSWeakSource &scene,
 					   OBSWeakSource &transition)
 {
-	if (!fileIO.readEnabled || fileIO.readPath.empty())
+	if (!fileIO.readEnabled || fileIO.readPath.empty()) {
 		return;
+	}
 
 	QFile file(QString::fromStdString(fileIO.readPath));
 	if (file.open(QIODevice::ReadOnly)) {
@@ -147,63 +175,82 @@ bool compareIgnoringLineEnding(QString &s1, QString &s2)
 	QTextStream s1stream(&s1);
 	QTextStream s2stream(&s2);
 
-	while (!s1stream.atEnd() && !s2stream.atEnd()) {
+	while (!s1stream.atEnd() || !s2stream.atEnd()) {
 		QString s1s = s1stream.readLine();
 		QString s2s = s2stream.readLine();
-		if (QString::compare(s1s, s2s, Qt::CaseSensitive) != 0) {
+		if (s1s != s2s) {
 			return false;
 		}
 	}
+
+	if (!s1stream.atEnd() && !s2stream.atEnd()) {
+		return false;
+	}
+
 	return true;
 }
 
+bool matchFileContent(QString &filedata, FileSwitch &s)
+{
+	if (s.onlyMatchIfChanged) {
+		size_t newHash = strHash(filedata.toUtf8().constData());
+		if (newHash == s.lastHash) {
+			return false;
+		}
+		s.lastHash = newHash;
+	}
+
+	if (s.useRegex) {
+		QRegExp rx(QString::fromStdString(s.text));
+		return rx.exactMatch(filedata);
+	}
+
+	QString text = QString::fromStdString(s.text);
+	return compareIgnoringLineEnding(text, filedata);
+}
+
 bool checkRemoteFileContent(FileSwitch &s)
 {
 	std::string data = getRemoteData(s.file);
-	bool ret = false;
-	if (s.useRegex) {
-		ret = QString::fromStdString(data).contains(
-			QRegularExpression(QString::fromStdString(s.text)));
-		return ret;
-	}
-	QString t = QString::fromStdString(s.text);
-	QString d = QString::fromStdString(data);
-
-	return compareIgnoringLineEnding(t, d);
+	QString qdata = QString::fromStdString(data);
+	return matchFileContent(qdata, s);
 }
 
 bool checkLocalFileContent(FileSwitch &s)
 {
-	bool equal = false;
 	QString t = QString::fromStdString(s.text);
 	QFile file(QString::fromStdString(s.file));
-	if (!file.open(QIODevice::ReadOnly))
+	if (s.file.empty() || !file.open(QIODevice::ReadOnly)) {
 		return false;
+	}
 
 	if (s.useTime) {
 		QDateTime newLastMod = QFileInfo(file).lastModified();
-		if (s.lastMod == newLastMod)
+		if (s.lastMod == newLastMod) {
 			return false;
+		}
 		s.lastMod = newLastMod;
 	}
 
-	if (s.useRegex) {
-		QTextStream in(&file);
-		QRegExp rx(t);
-		equal = rx.exactMatch(in.readAll());
-	} else {
-		QTextStream in(&file);
-		QString filedata = in.readAll();
-		equal = compareIgnoringLineEnding(filedata, t);
-	}
+	QString filedata = QTextStream(&file).readAll();
+	bool match = matchFileContent(filedata, s);
+
 	file.close();
-	return equal;
+	return match;
 }
 
 void SwitcherData::checkFileContent(bool &match, OBSWeakSource &scene,
 				    OBSWeakSource &transition)
 {
+	if (FileSwitch::pause) {
+		return;
+	}
+
 	for (FileSwitch &s : fileSwitches) {
+		if (!s.initialized()) {
+			continue;
+		}
+
 		bool equal = false;
 		if (s.remote) {
 			equal = checkRemoteFileContent(s);
@@ -212,149 +259,107 @@ void SwitcherData::checkFileContent(bool &match, OBSWeakSource &scene,
 		}
 
 		if (equal) {
-			scene = s.scene;
+			scene = s.getScene();
 			transition = s.transition;
 			match = true;
 
-			if (verbose)
+			if (verbose) {
 				s.logMatch();
+			}
 			break;
 		}
 	}
 }
 
-void SceneSwitcher::on_browseButton_3_clicked()
+void AdvSceneSwitcher::on_fileAdd_clicked()
 {
-	QString path = QFileDialog::getOpenFileName(
-		this, tr("Select a file to read from ..."), QDir::currentPath(),
-		tr("Any files (*.*)"));
-	if (!path.isEmpty())
-		ui->filePathLineEdit->setText(path);
-}
-
-void SceneSwitcher::on_fileType_currentIndexChanged(int idx)
-{
-	if (idx == -1)
-		return;
-	if (idx == LOCAL_FILE_IDX) {
-		ui->browseButton_3->setDisabled(false);
-		ui->fileContentTimeCheckBox->setDisabled(false);
-		ui->remoteFileWarningLabel->hide();
-	}
-	if (idx == REMOTE_FILE_IDX) {
-		ui->browseButton_3->setDisabled(true);
-		ui->fileContentTimeCheckBox->setDisabled(true);
-		ui->remoteFileWarningLabel->show();
-	}
-}
-
-void SceneSwitcher::on_fileAdd_clicked()
-{
-	QString sceneName = ui->fileScenes->currentText();
-	QString transitionName = ui->fileTransitions->currentText();
-	QString fileName = ui->filePathLineEdit->text();
-	QString text = ui->fileTextEdit->toPlainText();
-	bool remote = (ui->fileType->currentIndex() == REMOTE_FILE_IDX);
-	bool useRegex = ui->fileContentRegExCheckBox->isChecked();
-	bool useTime = ui->fileContentTimeCheckBox->isChecked();
-
-	if (sceneName.isEmpty() || transitionName.isEmpty() ||
-	    fileName.isEmpty() || text.isEmpty())
-		return;
-
-	OBSWeakSource source = GetWeakSourceByQString(sceneName);
-	OBSWeakSource transition = GetWeakTransitionByQString(transitionName);
-
-	QString switchText = MakeFileSwitchName(
-		sceneName, transitionName, fileName, text, useRegex, useTime);
-	QVariant v = QVariant::fromValue(switchText);
-
-	QListWidgetItem *item =
-		new QListWidgetItem(switchText, ui->fileScenesList);
-	item->setData(Qt::UserRole, v);
-
 	std::lock_guard<std::mutex> lock(switcher->m);
-	switcher->fileSwitches.emplace_back(source, transition,
-					    fileName.toUtf8().constData(),
-					    text.toUtf8().constData(), remote,
-					    useRegex, useTime);
+	switcher->fileSwitches.emplace_back();
+
+	listAddClicked(ui->fileSwitches,
+		       new FileSwitchWidget(this,
+					    &switcher->fileSwitches.back()),
+		       ui->fileAdd, &addPulse);
+
+	ui->fileHelp->setVisible(false);
 }
 
-void SceneSwitcher::on_fileRemove_clicked()
+void AdvSceneSwitcher::on_fileRemove_clicked()
 {
-	QListWidgetItem *item = ui->fileScenesList->currentItem();
-	if (!item)
-		return;
-
-	int idx = ui->fileScenesList->currentRow();
-	if (idx == -1)
+	QListWidgetItem *item = ui->fileSwitches->currentItem();
+	if (!item) {
 		return;
+	}
 
 	{
 		std::lock_guard<std::mutex> lock(switcher->m);
-
+		int idx = ui->fileSwitches->currentRow();
 		auto &switches = switcher->fileSwitches;
 		switches.erase(switches.begin() + idx);
 	}
-	qDeleteAll(ui->fileScenesList->selectedItems());
+
+	delete item;
 }
 
-void SceneSwitcher::on_fileScenesList_currentRowChanged(int idx)
+void AdvSceneSwitcher::on_fileSwitches_currentRowChanged(int idx)
 {
-	if (loading)
+	if (loading) {
 		return;
-	if (idx == -1)
+	}
+	if (idx == -1) {
 		return;
+	}
 
 	std::lock_guard<std::mutex> lock(switcher->m);
 
-	if ((int)switcher->fileSwitches.size() <= idx)
+	if ((int)switcher->fileSwitches.size() <= idx) {
 		return;
+	}
 	FileSwitch s = switcher->fileSwitches[idx];
-
-	std::string sceneName = GetWeakSourceName(s.scene);
-	std::string transitionName = GetWeakSourceName(s.transition);
-
-	ui->fileScenes->setCurrentText(sceneName.c_str());
-	ui->fileTransitions->setCurrentText(transitionName.c_str());
-	ui->fileTextEdit->setPlainText(s.text.c_str());
-	ui->filePathLineEdit->setText(s.file.c_str());
-	if (s.remote)
-		ui->fileType->setCurrentIndex(REMOTE_FILE_IDX);
-	else
-		ui->fileType->setCurrentIndex(LOCAL_FILE_IDX);
-	ui->fileContentRegExCheckBox->setChecked(s.useRegex);
-	ui->fileContentTimeCheckBox->setChecked(s.useTime);
-}
-
-void SceneSwitcher::on_fileUp_clicked()
-{
-	int index = ui->fileScenesList->currentRow();
-	if (index != -1 && index != 0) {
-		ui->fileScenesList->insertItem(
-			index - 1, ui->fileScenesList->takeItem(index));
-		ui->fileScenesList->setCurrentRow(index - 1);
-
-		std::lock_guard<std::mutex> lock(switcher->m);
-
-		iter_swap(switcher->fileSwitches.begin() + index,
-			  switcher->fileSwitches.begin() + index - 1);
+	if (s.remote) {
+		ui->remoteFileWarningLabel->show();
+	} else {
+		ui->remoteFileWarningLabel->hide();
 	}
 }
 
-void SceneSwitcher::on_fileDown_clicked()
+void AdvSceneSwitcher::on_fileUp_clicked()
 {
-	int index = ui->fileScenesList->currentRow();
-	if (index != -1 && index != ui->fileScenesList->count() - 1) {
-		ui->fileScenesList->insertItem(
-			index + 1, ui->fileScenesList->takeItem(index));
-		ui->fileScenesList->setCurrentRow(index + 1);
-
-		std::lock_guard<std::mutex> lock(switcher->m);
-
-		iter_swap(switcher->fileSwitches.begin() + index,
-			  switcher->fileSwitches.begin() + index + 1);
+	int index = ui->fileSwitches->currentRow();
+	if (!listMoveUp(ui->fileSwitches)) {
+		return;
 	}
+
+	FileSwitchWidget *s1 = (FileSwitchWidget *)ui->fileSwitches->itemWidget(
+		ui->fileSwitches->item(index));
+	FileSwitchWidget *s2 = (FileSwitchWidget *)ui->fileSwitches->itemWidget(
+		ui->fileSwitches->item(index - 1));
+	FileSwitchWidget::swapSwitchData(s1, s2);
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+
+	std::swap(switcher->fileSwitches[index],
+		  switcher->fileSwitches[index - 1]);
+}
+
+void AdvSceneSwitcher::on_fileDown_clicked()
+{
+	int index = ui->fileSwitches->currentRow();
+
+	if (!listMoveDown(ui->fileSwitches)) {
+		return;
+	}
+
+	FileSwitchWidget *s1 = (FileSwitchWidget *)ui->fileSwitches->itemWidget(
+		ui->fileSwitches->item(index));
+	FileSwitchWidget *s2 = (FileSwitchWidget *)ui->fileSwitches->itemWidget(
+		ui->fileSwitches->item(index + 1));
+	FileSwitchWidget::swapSwitchData(s1, s2);
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+
+	std::swap(switcher->fileSwitches[index],
+		  switcher->fileSwitches[index + 1]);
 }
 
 void SwitcherData::saveFileSwitches(obs_data_t *obj)
@@ -363,26 +368,8 @@ void SwitcherData::saveFileSwitches(obs_data_t *obj)
 	for (FileSwitch &s : switcher->fileSwitches) {
 		obs_data_t *array_obj = obs_data_create();
 
-		obs_source_t *source = obs_weak_source_get_source(s.scene);
-		obs_source_t *transition =
-			obs_weak_source_get_source(s.transition);
-
-		if (source && transition) {
-			const char *sceneName = obs_source_get_name(source);
-			const char *transitionName =
-				obs_source_get_name(transition);
-			obs_data_set_string(array_obj, "scene", sceneName);
-			obs_data_set_string(array_obj, "transition",
-					    transitionName);
-			obs_data_set_string(array_obj, "file", s.file.c_str());
-			obs_data_set_string(array_obj, "text", s.text.c_str());
-			obs_data_set_bool(array_obj, "remote", s.remote);
-			obs_data_set_bool(array_obj, "useRegex", s.useRegex);
-			obs_data_set_bool(array_obj, "useTime", s.useTime);
-			obs_data_array_push_back(fileArray, array_obj);
-			obs_source_release(source);
-			obs_source_release(transition);
-		}
+		s.save(array_obj);
+		obs_data_array_push_back(fileArray, array_obj);
 
 		obs_data_release(array_obj);
 	}
@@ -405,19 +392,8 @@ void SwitcherData::loadFileSwitches(obs_data_t *obj)
 	for (size_t i = 0; i < count; i++) {
 		obs_data_t *array_obj = obs_data_array_item(fileArray, i);
 
-		const char *scene = obs_data_get_string(array_obj, "scene");
-		const char *transition =
-			obs_data_get_string(array_obj, "transition");
-		const char *file = obs_data_get_string(array_obj, "file");
-		const char *text = obs_data_get_string(array_obj, "text");
-		bool remote = obs_data_get_bool(array_obj, "remote");
-		bool useRegex = obs_data_get_bool(array_obj, "useRegex");
-		bool useTime = obs_data_get_bool(array_obj, "useTime");
-
-		switcher->fileSwitches.emplace_back(
-			GetWeakSourceByName(scene),
-			GetWeakTransitionByName(transition), file, text, remote,
-			useRegex, useTime);
+		switcher->fileSwitches.emplace_back();
+		fileSwitches.back().load(array_obj);
 
 		obs_data_release(array_obj);
 	}
@@ -431,30 +407,32 @@ void SwitcherData::loadFileSwitches(obs_data_t *obj)
 	switcher->fileIO.writePath = obs_data_get_string(obj, "writePath");
 }
 
-void SceneSwitcher::setupFileTab()
+void AdvSceneSwitcher::setupFileTab()
 {
-	populateSceneSelection(ui->fileScenes, false);
-	populateTransitionSelection(ui->fileTransitions);
-
-	ui->fileType->addItem("local");
-	ui->fileType->addItem("remote");
 	ui->remoteFileWarningLabel->setText(
-		"Note that the scene switcher will try to access the remote location every " +
-		QString::number(switcher->interval) + "ms");
+		obs_module_text("AdvSceneSwitcher.fileTab.remoteFileWarning1") +
+		QString::number(switcher->interval) +
+		obs_module_text("AdvSceneSwitcher.fileTab.remoteFileWarning2"));
+	ui->remoteFileWarningLabel->hide();
 
-	if (switcher->curl)
+	if (switcher->curl) {
 		ui->libcurlWarning->setVisible(false);
+	}
 
 	for (auto &s : switcher->fileSwitches) {
-		std::string sceneName = GetWeakSourceName(s.scene);
-		std::string transitionName = GetWeakSourceName(s.transition);
-		QString listText = MakeFileSwitchName(
-			sceneName.c_str(), transitionName.c_str(),
-			s.file.c_str(), s.text.c_str(), s.useRegex, s.useTime);
+		QListWidgetItem *item;
+		item = new QListWidgetItem(ui->fileSwitches);
+		ui->fileSwitches->addItem(item);
+		FileSwitchWidget *sw = new FileSwitchWidget(this, &s);
+		item->setSizeHint(sw->minimumSizeHint());
+		ui->fileSwitches->setItemWidget(item, sw);
+	}
 
-		QListWidgetItem *item =
-			new QListWidgetItem(listText, ui->fileScenesList);
-		item->setData(Qt::UserRole, listText);
+	if (switcher->fileSwitches.size() == 0) {
+		addPulse = PulseWidget(ui->fileAdd, QColor(Qt::green));
+		ui->fileHelp->setVisible(true);
+	} else {
+		ui->fileHelp->setVisible(false);
 	}
 
 	ui->readPathLineEdit->setText(
@@ -472,26 +450,245 @@ void SceneSwitcher::setupFileTab()
 	}
 }
 
-static inline QString MakeFileSwitchName(const QString &scene,
-					 const QString &transition,
-					 const QString &fileName,
-					 const QString &text, bool useRegex,
-					 bool useTime)
+void FileSwitch::save(obs_data_t *obj)
 {
-	QString switchName = QStringLiteral("Switch to ") + scene +
-			     QStringLiteral(" using ") + transition +
-			     QStringLiteral(" if ") + fileName;
-	if (useTime)
-		switchName += QStringLiteral(" was modified and");
-	switchName += QStringLiteral(" contains");
-	if (useRegex)
-		switchName += QStringLiteral(" (RegEx): \n\"");
-	else
-		switchName += QStringLiteral(": \n\"");
-	if (text.length() > 30)
-		switchName += text.left(27) + QStringLiteral("...\"");
-	else
-		switchName += text + QStringLiteral("\"");
+	SceneSwitcherEntry::save(obj);
 
-	return switchName;
+	obs_data_set_string(obj, "file", file.c_str());
+	obs_data_set_string(obj, "text", text.c_str());
+	obs_data_set_bool(obj, "remote", remote);
+	obs_data_set_bool(obj, "useRegex", useRegex);
+	obs_data_set_bool(obj, "useTime", useTime);
+	obs_data_set_bool(obj, "onlyMatchIfChanged", onlyMatchIfChanged);
+}
+
+// To be removed in future version
+bool loadOldFile(obs_data_t *obj, FileSwitch *s)
+{
+	if (!s) {
+		return false;
+	}
+
+	const char *scene = obs_data_get_string(obj, "scene");
+
+	if (strcmp(scene, "") == 0) {
+		return false;
+	}
+
+	s->scene = GetWeakSourceByName(scene);
+
+	const char *transition = obs_data_get_string(obj, "transition");
+	s->transition = GetWeakTransitionByName(transition);
+
+	s->file = obs_data_get_string(obj, "file");
+	s->text = obs_data_get_string(obj, "text");
+	s->remote = obs_data_get_bool(obj, "remote");
+	s->useRegex = obs_data_get_bool(obj, "useRegex");
+	s->useTime = obs_data_get_bool(obj, "useTime");
+	s->onlyMatchIfChanged = obs_data_get_bool(obj, "onlyMatchIfChanged");
+	s->usePreviousScene = strcmp(scene, previous_scene_name) == 0;
+
+	return true;
+}
+
+void FileSwitch::load(obs_data_t *obj)
+{
+	if (loadOldFile(obj, this)) {
+		return;
+	}
+
+	SceneSwitcherEntry::load(obj);
+
+	file = obs_data_get_string(obj, "file");
+	text = obs_data_get_string(obj, "text");
+	remote = obs_data_get_bool(obj, "remote");
+	useRegex = obs_data_get_bool(obj, "useRegex");
+	useTime = obs_data_get_bool(obj, "useTime");
+	onlyMatchIfChanged = obs_data_get_bool(obj, "onlyMatchIfChanged");
+}
+
+FileSwitchWidget::FileSwitchWidget(QWidget *parent, FileSwitch *s)
+	: SwitchWidget(parent, s, true, true)
+{
+	fileType = new QComboBox();
+	filePath = new QLineEdit();
+	browseButton =
+		new QPushButton(obs_module_text("AdvSceneSwitcher.browse"));
+	browseButton->setStyleSheet("border:1px solid gray;");
+	matchText = new QPlainTextEdit();
+	useRegex = new QCheckBox(
+		obs_module_text("AdvSceneSwitcher.fileTab.useRegExp"));
+	checkModificationDate = new QCheckBox(obs_module_text(
+		"AdvSceneSwitcher.fileTab.checkfileContentTime"));
+	checkFileContent = new QCheckBox(
+		obs_module_text("AdvSceneSwitcher.fileTab.checkfileContent"));
+
+	QWidget::connect(fileType, SIGNAL(currentIndexChanged(int)), this,
+			 SLOT(FileTypeChanged(int)));
+	QWidget::connect(filePath, SIGNAL(editingFinished()), this,
+			 SLOT(FilePathChanged()));
+	QWidget::connect(browseButton, SIGNAL(clicked()), this,
+			 SLOT(BrowseButtonClicked()));
+	QWidget::connect(matchText, SIGNAL(textChanged()), this,
+			 SLOT(MatchTextChanged()));
+	QWidget::connect(useRegex, SIGNAL(stateChanged(int)), this,
+			 SLOT(UseRegexChanged(int)));
+	QWidget::connect(checkModificationDate, SIGNAL(stateChanged(int)), this,
+			 SLOT(CheckModificationDateChanged(int)));
+	QWidget::connect(checkFileContent, SIGNAL(stateChanged(int)), this,
+			 SLOT(CheckFileContentChanged(int)));
+
+	fileType->addItem(obs_module_text("AdvSceneSwitcher.fileTab.local"));
+	fileType->addItem(obs_module_text("AdvSceneSwitcher.fileTab.remote"));
+
+	if (s) {
+		if (s->remote) {
+			fileType->setCurrentIndex(1);
+		} else {
+			fileType->setCurrentIndex(0);
+		}
+		filePath->setText(QString::fromStdString(s->file));
+		matchText->setPlainText(QString::fromStdString(s->text));
+		useRegex->setChecked(s->useRegex);
+		checkModificationDate->setChecked(s->useTime);
+		checkFileContent->setChecked(s->onlyMatchIfChanged);
+	}
+
+	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
+		{"{{fileType}}", fileType},
+		{"{{filePath}}", filePath},
+		{"{{browseButton}}", browseButton},
+		{"{{matchText}}", matchText},
+		{"{{useRegex}}", useRegex},
+		{"{{checkModificationDate}}", checkModificationDate},
+		{"{{checkFileContent}}", checkFileContent},
+		{"{{scenes}}", scenes},
+		{"{{transitions}}", transitions}};
+
+	QVBoxLayout *mainLayout = new QVBoxLayout;
+	QHBoxLayout *line1Layout = new QHBoxLayout;
+	QHBoxLayout *line2Layout = new QHBoxLayout;
+	QHBoxLayout *line3Layout = new QHBoxLayout;
+	placeWidgets(obs_module_text("AdvSceneSwitcher.fileTab.entry"),
+		     line1Layout, widgetPlaceholders);
+	placeWidgets(obs_module_text("AdvSceneSwitcher.fileTab.entry2"),
+		     line2Layout, widgetPlaceholders, false);
+	placeWidgets(obs_module_text("AdvSceneSwitcher.fileTab.entry3"),
+		     line3Layout, widgetPlaceholders);
+	mainLayout->addLayout(line1Layout);
+	mainLayout->addLayout(line2Layout);
+	mainLayout->addLayout(line3Layout);
+
+	setLayout(mainLayout);
+
+	switchData = s;
+
+	loading = false;
+}
+
+FileSwitch *FileSwitchWidget::getSwitchData()
+{
+	return switchData;
+}
+
+void FileSwitchWidget::setSwitchData(FileSwitch *s)
+{
+	switchData = s;
+}
+
+void FileSwitchWidget::swapSwitchData(FileSwitchWidget *s1,
+				      FileSwitchWidget *s2)
+{
+	SwitchWidget::swapSwitchData(s1, s2);
+
+	FileSwitch *t = s1->getSwitchData();
+	s1->setSwitchData(s2->getSwitchData());
+	s2->setSwitchData(t);
+}
+
+void FileSwitchWidget::FileTypeChanged(int index)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	if ((file_type)index == LOCAL) {
+		browseButton->setDisabled(false);
+		checkModificationDate->setDisabled(false);
+	} else {
+		browseButton->setDisabled(true);
+		checkModificationDate->setDisabled(true);
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->remote = (file_type)index == REMOTE;
+}
+
+void FileSwitchWidget::FilePathChanged()
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->file = filePath->text().toUtf8().constData();
+}
+
+void FileSwitchWidget::BrowseButtonClicked()
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	QString path = QFileDialog::getOpenFileName(
+		this,
+		tr(obs_module_text("AdvSceneSwitcher.fileTab.selectRead")),
+		QDir::currentPath(),
+		tr(obs_module_text("AdvSceneSwitcher.fileTab.anyFileType")));
+	if (path.isEmpty()) {
+		return;
+	}
+
+	filePath->setText(path);
+	FilePathChanged();
+}
+
+void FileSwitchWidget::MatchTextChanged()
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->text = matchText->toPlainText().toUtf8().constData();
+}
+
+void FileSwitchWidget::UseRegexChanged(int state)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->useRegex = state;
+}
+
+void FileSwitchWidget::CheckModificationDateChanged(int state)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->useTime = state;
+}
+
+void FileSwitchWidget::CheckFileContentChanged(int state)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->onlyMatchIfChanged = state;
 }

src/switch-generic.cpp

@@ -0,0 +1,281 @@
+#include "headers/advanced-scene-switcher.hpp"
+#include "headers/utility.hpp"
+
+bool SceneSwitcherEntry::initialized()
+{
+	return (usePreviousScene || WeakSourceValid(scene) ||
+		SceneGroupValid(group)) &&
+	       transition;
+}
+
+bool SceneSwitcherEntry::valid()
+{
+	return !initialized() || ((usePreviousScene || WeakSourceValid(scene) ||
+				   SceneGroupValid(group)) &&
+				  WeakSourceValid(transition));
+}
+
+void SceneSwitcherEntry::logMatchScene()
+{
+	std::string sceneName = previous_scene_name;
+	if (!usePreviousScene) {
+		sceneName = GetWeakSourceName(scene);
+	}
+	blog(LOG_INFO, "match for '%s' - switch to scene '%s'", getType(),
+	     sceneName.c_str());
+}
+
+void SceneSwitcherEntry::logMatchSceneGroup()
+{
+	if (group->scenes.empty()) {
+		blog(LOG_INFO,
+		     "match for '%s' - but no scenes specified in '%s'",
+		     getType(), group->name.c_str());
+		return;
+	}
+
+	std::string sceneName = GetWeakSourceName(group->getCurrentScene());
+
+	blog(LOG_INFO, "match for '%s' - switch to scene '%s' using '%s'",
+	     getType(), sceneName.c_str(), group->name.c_str());
+}
+
+void SceneSwitcherEntry::logMatch()
+{
+	if (targetType == SwitchTargetType::Scene) {
+		logMatchScene();
+	} else if (targetType == SwitchTargetType::SceneGroup) {
+		logMatchSceneGroup();
+	}
+}
+
+OBSWeakSource SceneSwitcherEntry::getScene()
+{
+	if (targetType == SwitchTargetType::Scene) {
+		if (usePreviousScene && switcher) {
+			return switcher->previousScene;
+		}
+		return scene;
+	} else if (targetType == SwitchTargetType::SceneGroup) {
+		return group->getNextScene();
+	}
+	return nullptr;
+}
+
+void SceneSwitcherEntry::save(obs_data_t *obj, const char *targetTypeSaveName,
+			      const char *targetSaveName,
+			      const char *transitionSaveName)
+{
+	obs_data_set_int(obj, targetTypeSaveName, static_cast<int>(targetType));
+
+	std::string targetName = "";
+
+	if (targetType == SwitchTargetType::Scene) {
+		if (usePreviousScene) {
+			targetName = previous_scene_name;
+		} else {
+			targetName = GetWeakSourceName(scene);
+		}
+	} else if (targetType == SwitchTargetType::SceneGroup) {
+		targetName = group->name.c_str();
+	}
+
+	obs_data_set_string(obj, targetSaveName, targetName.c_str());
+
+	obs_data_set_string(obj, transitionSaveName,
+			    GetWeakSourceName(transition).c_str());
+}
+
+void SceneSwitcherEntry::load(obs_data_t *obj, const char *targetTypeLoadName,
+			      const char *targetLoadName,
+			      const char *transitionLoadName)
+{
+	targetType = static_cast<SwitchTargetType>(
+		obs_data_get_int(obj, targetTypeLoadName));
+
+	const char *targetName = obs_data_get_string(obj, targetLoadName);
+
+	if (targetType == SwitchTargetType::Scene) {
+		usePreviousScene = strcmp(targetName, previous_scene_name) == 0;
+		if (!usePreviousScene) {
+			scene = GetWeakSourceByName(targetName);
+		}
+	} else if (targetType == SwitchTargetType::SceneGroup) {
+		group = GetSceneGroupByName(targetName);
+	}
+
+	const char *transitionName =
+		obs_data_get_string(obj, transitionLoadName);
+	transition = GetWeakTransitionByName(transitionName);
+
+	usePreviousScene = strcmp(targetName, previous_scene_name) == 0;
+}
+
+void SwitchWidget::SceneGroupAdd(const QString &name)
+{
+	if (!scenes) {
+		return;
+	}
+
+	scenes->addItem(name);
+}
+
+void SwitchWidget::SceneGroupRemove(const QString &name)
+{
+	if (!scenes) {
+		return;
+	}
+
+	int idx = scenes->findText(name);
+
+	if (idx == -1) {
+		return;
+	}
+
+	scenes->removeItem(idx);
+
+	if (switchData && switchData->group == GetSceneGroupByQString(name)) {
+		std::lock_guard<std::mutex> lock(switcher->m);
+		switchData->targetType = SwitchTargetType::Scene;
+		switchData->scene = nullptr;
+	}
+
+	scenes->setCurrentIndex(0);
+}
+
+void SwitchWidget::SceneGroupRename(const QString &oldName,
+				    const QString &newName)
+{
+	if (!scenes) {
+		return;
+	}
+
+	bool renameSelected = scenes->currentText() == oldName;
+	int idx = scenes->findText(oldName);
+
+	if (idx == -1) {
+		return;
+	}
+
+	scenes->removeItem(idx);
+	scenes->insertItem(idx, newName);
+
+	if (renameSelected) {
+		scenes->setCurrentIndex(scenes->findText(newName));
+	}
+}
+
+SwitchWidget::SwitchWidget(QWidget *parent, SceneSwitcherEntry *s,
+			   bool usePreviousScene, bool addSceneGroup)
+{
+	scenes = new QComboBox();
+	transitions = new QComboBox();
+
+	// Depending on selected OBS theme some widgets might have a different
+	// background color than the listwidget and might look out of place
+	setStyleSheet("QLabel { background-color: transparent; }\
+		       QSlider { background-color: transparent; }\
+		       QCheckBox { background-color: transparent; }");
+
+	QWidget::connect(scenes, SIGNAL(currentTextChanged(const QString &)),
+			 this, SLOT(SceneChanged(const QString &)));
+	QWidget::connect(transitions,
+			 SIGNAL(currentTextChanged(const QString &)), this,
+			 SLOT(TransitionChanged(const QString &)));
+
+	QWidget::connect(parent, SIGNAL(SceneGroupAdded(const QString &)), this,
+			 SLOT(SceneGroupAdd(const QString &)));
+	QWidget::connect(parent, SIGNAL(SceneGroupRemoved(const QString &)),
+			 this, SLOT(SceneGroupRemove(const QString &)));
+	QWidget::connect(
+		parent,
+		SIGNAL(SceneGroupRenamed(const QString &, const QString &)),
+		this, SLOT(SceneGroupRename(const QString &, const QString &)));
+
+	AdvSceneSwitcher::populateSceneSelection(scenes, usePreviousScene,
+						 addSceneGroup);
+	AdvSceneSwitcher::populateTransitionSelection(transitions);
+
+	switchData = s;
+	showSwitchData();
+}
+
+SceneSwitcherEntry *SwitchWidget::getSwitchData()
+{
+	return switchData;
+}
+
+void SwitchWidget::setSwitchData(SceneSwitcherEntry *s)
+{
+	switchData = s;
+}
+
+void SwitchWidget::showSwitchData()
+{
+	if (!switchData) {
+		return;
+	}
+
+	transitions->setCurrentText(
+		GetWeakSourceName(switchData->transition).c_str());
+
+	if (switchData->usePreviousScene) {
+		scenes->setCurrentText(obs_module_text(
+			"AdvSceneSwitcher.selectPreviousScene"));
+		return;
+	}
+
+	scenes->setCurrentText(GetWeakSourceName(switchData->scene).c_str());
+
+	if (switchData->group &&
+	    switchData->targetType == SwitchTargetType::SceneGroup) {
+		scenes->setCurrentText(
+			QString::fromStdString(switchData->group->name));
+	}
+}
+
+void SwitchWidget::swapSwitchData(SwitchWidget *s1, SwitchWidget *s2)
+{
+	SceneSwitcherEntry *t = s1->getSwitchData();
+	s1->setSwitchData(s2->getSwitchData());
+	s2->setSwitchData(t);
+}
+
+bool isPreviousScene(const QString &text)
+{
+	return text.compare(obs_module_text(
+		       "AdvSceneSwitcher.selectPreviousScene")) == 0;
+}
+
+void SwitchWidget::SceneChanged(const QString &text)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+
+	switchData->usePreviousScene = isPreviousScene(text);
+	if (switchData->usePreviousScene) {
+		switchData->targetType = SwitchTargetType::Scene;
+		return;
+	}
+
+	switchData->scene = GetWeakSourceByQString(text);
+	switchData->targetType = SwitchTargetType::Scene;
+
+	if (!switchData->scene) {
+		switchData->group = GetSceneGroupByQString(text);
+		switchData->targetType = SwitchTargetType::SceneGroup;
+	}
+}
+
+void SwitchWidget::TransitionChanged(const QString &text)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->transition = GetWeakTransitionByQString(text);
+}

src/switch-idle.cpp

@@ -1,18 +1,21 @@
 #include <regex>
 
 #include "headers/advanced-scene-switcher.hpp"
+#include "headers/utility.hpp"
+
+bool IdleData::pause = false;
+IdleWidget *idleWidget = nullptr;
 
 void SwitcherData::checkIdleSwitch(bool &match, OBSWeakSource &scene,
 				   OBSWeakSource &transition)
 {
-	if (!idleData.idleEnable)
+	if (!idleData.idleEnable || IdleData::pause) {
 		return;
+	}
 
 	std::string title;
 	bool ignoreIdle = false;
-	//lock.unlock();
 	GetCurrentWindowTitle(title);
-	//lock.lock();
 
 	for (std::string &window : ignoreIdleWindows) {
 		if (window == title) {
@@ -36,94 +39,45 @@ void SwitcherData::checkIdleSwitch(bool &match, OBSWeakSource &scene,
 	}
 
 	if (!ignoreIdle && secondsSinceLastInput() > idleData.time) {
-		if (idleData.alreadySwitched)
+		if (idleData.alreadySwitched) {
 			return;
-		scene = (idleData.usePreviousScene) ? previousScene
-						    : idleData.scene;
+		}
+		scene = idleData.getScene();
 		transition = idleData.transition;
 		match = true;
 		idleData.alreadySwitched = true;
 
-		if (verbose)
+		if (verbose) {
 			idleData.logMatch();
+		}
 	} else
 		idleData.alreadySwitched = false;
 }
 
-void SceneSwitcher::on_idleCheckBox_stateChanged(int state)
+void AdvSceneSwitcher::on_idleCheckBox_stateChanged(int state)
 {
-	if (loading)
+	if (loading) {
 		return;
+	}
 
 	std::lock_guard<std::mutex> lock(switcher->m);
 	if (!state) {
-		ui->idleScenes->setDisabled(true);
-		ui->idleSpinBox->setDisabled(true);
-		ui->idleTransitions->setDisabled(true);
-
 		switcher->idleData.idleEnable = false;
+		idleWidget->setDisabled(true);
 	} else {
-		ui->idleScenes->setDisabled(false);
-		ui->idleSpinBox->setDisabled(false);
-		ui->idleTransitions->setDisabled(false);
-
 		switcher->idleData.idleEnable = true;
-
-		UpdateIdleDataTransition(ui->idleTransitions->currentText());
-		UpdateIdleDataScene(ui->idleScenes->currentText());
+		idleWidget->setDisabled(false);
 	}
 }
 
-void SceneSwitcher::UpdateIdleDataTransition(const QString &name)
+void AdvSceneSwitcher::on_ignoreIdleWindows_currentRowChanged(int idx)
 {
-	obs_weak_source_t *transition = GetWeakTransitionByQString(name);
-	switcher->idleData.transition = transition;
-}
-
-void SceneSwitcher::UpdateIdleDataScene(const QString &name)
-{
-	switcher->idleData.usePreviousScene = (name == previous_scene_name);
-	obs_source_t *scene = obs_get_source_by_name(name.toUtf8().constData());
-	obs_weak_source_t *ws = obs_source_get_weak_source(scene);
-
-	switcher->idleData.scene = ws;
-
-	obs_weak_source_release(ws);
-	obs_source_release(scene);
-}
-
-void SceneSwitcher::on_idleTransitions_currentTextChanged(const QString &text)
-{
-	if (loading)
+	if (loading) {
 		return;
-
-	std::lock_guard<std::mutex> lock(switcher->m);
-	UpdateIdleDataTransition(text);
-}
-
-void SceneSwitcher::on_idleScenes_currentTextChanged(const QString &text)
-{
-	if (loading)
-		return;
-
-	std::lock_guard<std::mutex> lock(switcher->m);
-	UpdateIdleDataScene(text);
-}
-
-void SceneSwitcher::on_idleSpinBox_valueChanged(int i)
-{
-	if (loading)
-		return;
-	std::lock_guard<std::mutex> lock(switcher->m);
-	switcher->idleData.time = i;
-}
-
-void SceneSwitcher::on_ignoreIdleWindows_currentRowChanged(int idx)
-{
-	if (loading)
-		return;
-	if (idx == -1)
+	}
+	if (idx == -1) {
 		return;
+	}
 
 	QListWidgetItem *item = ui->ignoreIdleWindows->item(idx);
 
@@ -138,12 +92,13 @@ void SceneSwitcher::on_ignoreIdleWindows_currentRowChanged(int idx)
 	}
 }
 
-void SceneSwitcher::on_ignoreIdleAdd_clicked()
+void AdvSceneSwitcher::on_ignoreIdleAdd_clicked()
 {
 	QString windowName = ui->ignoreIdleWindowsWindows->currentText();
 
-	if (windowName.isEmpty())
+	if (windowName.isEmpty()) {
 		return;
+	}
 
 	QVariant v = QVariant::fromValue(windowName);
 
@@ -162,11 +117,12 @@ void SceneSwitcher::on_ignoreIdleAdd_clicked()
 	}
 }
 
-void SceneSwitcher::on_ignoreIdleRemove_clicked()
+void AdvSceneSwitcher::on_ignoreIdleRemove_clicked()
 {
 	QListWidgetItem *item = ui->ignoreIdleWindows->currentItem();
-	if (!item)
+	if (!item) {
 		return;
+	}
 
 	QString windowName = item->data(Qt::UserRole).toString();
 
@@ -187,7 +143,7 @@ void SceneSwitcher::on_ignoreIdleRemove_clicked()
 	delete item;
 }
 
-int SceneSwitcher::IgnoreIdleWindowsFindByData(const QString &window)
+int AdvSceneSwitcher::IgnoreIdleWindowsFindByData(const QString &window)
 {
 	int count = ui->ignoreIdleWindows->count();
 	int idx = -1;
@@ -217,17 +173,7 @@ void SwitcherData::saveIdleSwitches(obs_data_t *obj)
 	obs_data_set_array(obj, "ignoreIdleWindows", ignoreIdleWindowsArray);
 	obs_data_array_release(ignoreIdleWindowsArray);
 
-	std::string idleSceneName = GetWeakSourceName(switcher->idleData.scene);
-	std::string idleTransitionName =
-		GetWeakSourceName(switcher->idleData.transition);
-	obs_data_set_bool(obj, "idleEnable", switcher->idleData.idleEnable);
-	obs_data_set_string(obj, "idleSceneName",
-			    switcher->idleData.usePreviousScene
-				    ? previous_scene_name
-				    : idleSceneName.c_str());
-	obs_data_set_string(obj, "idleTransitionName",
-			    idleTransitionName.c_str());
-	obs_data_set_int(obj, "idleTime", switcher->idleData.time);
+	idleData.save(obj);
 }
 
 void SwitcherData::loadIdleSwitches(obs_data_t *obj)
@@ -250,24 +196,14 @@ void SwitcherData::loadIdleSwitches(obs_data_t *obj)
 	}
 	obs_data_array_release(ignoreIdleWindowsArray);
 
-	std::string idleSceneName = obs_data_get_string(obj, "idleSceneName");
-	std::string idleTransitionName =
-		obs_data_get_string(obj, "idleTransitionName");
-	switcher->idleData.scene = GetWeakSourceByName(idleSceneName.c_str());
-	switcher->idleData.transition =
-		GetWeakTransitionByName(idleTransitionName.c_str());
 	obs_data_set_default_bool(obj, "idleEnable", false);
-	switcher->idleData.idleEnable = obs_data_get_bool(obj, "idleEnable");
 	obs_data_set_default_int(obj, "idleTime", default_idle_time);
-	switcher->idleData.time = obs_data_get_int(obj, "idleTime");
-	switcher->idleData.usePreviousScene =
-		(idleSceneName == previous_scene_name);
+
+	idleData.load(obj);
 }
 
-void SceneSwitcher::setupIdleTab()
+void AdvSceneSwitcher::setupIdleTab()
 {
-	populateSceneSelection(ui->idleScenes, true);
-	populateTransitionSelection(ui->idleTransitions);
 	populateWindowSelection(ui->ignoreIdleWindowsWindows);
 
 	for (auto &window : switcher->ignoreIdleWindows) {
@@ -278,22 +214,71 @@ void SceneSwitcher::setupIdleTab()
 		item->setData(Qt::UserRole, text);
 	}
 
+	idleWidget = new IdleWidget(this, &switcher->idleData);
+	ui->idleWidgetLayout->addWidget(idleWidget);
 	ui->idleCheckBox->setChecked(switcher->idleData.idleEnable);
-	ui->idleScenes->setCurrentText(
-		switcher->idleData.usePreviousScene
-			? previous_scene_name
-			: GetWeakSourceName(switcher->idleData.scene).c_str());
-	ui->idleTransitions->setCurrentText(
-		GetWeakSourceName(switcher->idleData.transition).c_str());
-	ui->idleSpinBox->setValue(switcher->idleData.time);
 
 	if (ui->idleCheckBox->checkState()) {
-		ui->idleScenes->setDisabled(false);
-		ui->idleSpinBox->setDisabled(false);
-		ui->idleTransitions->setDisabled(false);
+		idleWidget->setDisabled(false);
 	} else {
-		ui->idleScenes->setDisabled(true);
-		ui->idleSpinBox->setDisabled(true);
-		ui->idleTransitions->setDisabled(true);
+		idleWidget->setDisabled(true);
 	}
 }
+
+void IdleData::save(obs_data_t *obj)
+{
+	SceneSwitcherEntry::save(obj, "idleTargetType", "idleSceneName",
+				 "idleTransitionName");
+
+	obs_data_set_bool(obj, "idleEnable", idleEnable);
+	obs_data_set_int(obj, "idleTime", time);
+}
+
+void IdleData::load(obs_data_t *obj)
+{
+	SceneSwitcherEntry::load(obj, "idleTargetType", "idleSceneName",
+				 "idleTransitionName");
+
+	idleEnable = obs_data_get_bool(obj, "idleEnable");
+	time = obs_data_get_int(obj, "idleTime");
+}
+
+IdleWidget::IdleWidget(QWidget *parent, IdleData *s)
+	: SwitchWidget(parent, s, true, true)
+{
+	duration = new QSpinBox();
+
+	duration->setMinimum(0);
+	duration->setMaximum(1000000);
+	duration->setSuffix("s");
+
+	QWidget::connect(duration, SIGNAL(valueChanged(int)), this,
+			 SLOT(DurationChanged(int)));
+
+	if (s) {
+		duration->setValue(s->time);
+	}
+
+	QHBoxLayout *mainLayout = new QHBoxLayout;
+	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
+		{"{{duration}}", duration},
+		{"{{scenes}}", scenes},
+		{"{{transitions}}", transitions}};
+	placeWidgets(obs_module_text("AdvSceneSwitcher.idleTab.idleswitch"),
+		     mainLayout, widgetPlaceholders);
+	setLayout(mainLayout);
+
+	switchData = s;
+
+	loading = false;
+}
+
+void IdleWidget::DurationChanged(int dur)
+{
+	if (loading) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switcher->idleData.time = dur;
+}

src/switch-media.cpp

@@ -1,175 +1,200 @@
 #include "headers/advanced-scene-switcher.hpp"
+#include "headers/utility.hpp"
 
-void SceneSwitcher::on_mediaSwitches_currentRowChanged(int idx)
+bool MediaSwitch::pause = false;
+static QMetaObject::Connection addPulse;
+
+constexpr auto media_played_to_end_idx = 8;
+constexpr auto media_any_idx = 9;
+
+void AdvSceneSwitcher::on_mediaAdd_clicked()
 {
-	if (loading)
-		return;
-	if (idx == -1)
-		return;
-
-	QListWidgetItem *item = ui->mediaSwitches->item(idx);
-
-	QString mediaSceneStr = item->data(Qt::UserRole).toString();
-
 	std::lock_guard<std::mutex> lock(switcher->m);
-	for (auto &s : switcher->mediaSwitches) {
-		if (mediaSceneStr.compare(s.mediaSwitchStr.c_str()) == 0) {
-			QString sceneName = GetWeakSourceName(s.scene).c_str();
-			QString sourceName =
-				GetWeakSourceName(s.source).c_str();
-			QString transitionName =
-				GetWeakSourceName(s.transition).c_str();
-			ui->mediaScenes->setCurrentText(sceneName);
-			ui->mediaSources->setCurrentText(sourceName);
-			ui->mediaTransitions->setCurrentText(transitionName);
-			ui->mediaStates->setCurrentIndex(s.state);
-			ui->mediaTimeRestrictions->setCurrentIndex(
-				s.restriction);
-			ui->mediaTime->setValue(s.time);
-			break;
-		}
-	}
+	switcher->mediaSwitches.emplace_back();
+
+	listAddClicked(ui->mediaSwitches,
+		       new MediaSwitchWidget(this,
+					     &switcher->mediaSwitches.back()),
+		       ui->mediaAdd, &addPulse);
+
+	ui->mediaHelp->setVisible(false);
 }
 
-void SceneSwitcher::on_mediaAdd_clicked()
-{
-	QString sourceName = ui->mediaSources->currentText();
-	QString sceneName = ui->mediaScenes->currentText();
-	QString transitionName = ui->mediaTransitions->currentText();
-	obs_media_state state =
-		(obs_media_state)ui->mediaStates->currentIndex();
-	time_restriction restriction =
-		(time_restriction)ui->mediaTimeRestrictions->currentIndex();
-	uint64_t time = ui->mediaTime->value();
-
-	if (sceneName.isEmpty() || transitionName.isEmpty() ||
-	    sourceName.isEmpty())
-		return;
-
-	OBSWeakSource source = GetWeakSourceByQString(sourceName);
-	OBSWeakSource scene = GetWeakSourceByQString(sceneName);
-	OBSWeakSource transition = GetWeakTransitionByQString(transitionName);
-
-	QString switchText = MakeMediaSwitchName(sourceName, sceneName,
-						 transitionName, state,
-						 restriction, time);
-	QVariant v = QVariant::fromValue(switchText);
-
-	QListWidgetItem *item =
-		new QListWidgetItem(switchText, ui->mediaSwitches);
-	item->setData(Qt::UserRole, v);
-
-	std::lock_guard<std::mutex> lock(switcher->m);
-	switcher->mediaSwitches.emplace_back(
-		scene, source, transition, state, restriction, time,
-		(sceneName == QString(previous_scene_name)),
-		switchText.toUtf8().constData());
-}
-
-void SceneSwitcher::on_mediaRemove_clicked()
+void AdvSceneSwitcher::on_mediaRemove_clicked()
 {
 	QListWidgetItem *item = ui->mediaSwitches->currentItem();
-	if (!item)
+	if (!item) {
 		return;
+	}
 
-	std::string mediaStr =
-		item->data(Qt::UserRole).toString().toUtf8().constData();
 	{
 		std::lock_guard<std::mutex> lock(switcher->m);
+		int idx = ui->mediaSwitches->currentRow();
 		auto &switches = switcher->mediaSwitches;
-
-		for (auto it = switches.begin(); it != switches.end(); ++it) {
-			auto &s = *it;
-
-			if (s.mediaSwitchStr == mediaStr) {
-				switches.erase(it);
-				break;
-			}
-		}
+		switches.erase(switches.begin() + idx);
 	}
 
 	delete item;
 }
 
-void SceneSwitcher::on_mediaUp_clicked()
+void AdvSceneSwitcher::on_mediaUp_clicked()
 {
 	int index = ui->mediaSwitches->currentRow();
-	if (index != -1 && index != 0) {
-		ui->mediaSwitches->insertItem(
-			index - 1, ui->mediaSwitches->takeItem(index));
-		ui->mediaSwitches->setCurrentRow(index - 1);
-
-		std::lock_guard<std::mutex> lock(switcher->m);
-
-		iter_swap(switcher->mediaSwitches.begin() + index,
-			  switcher->mediaSwitches.begin() + index - 1);
-	}
-}
-
-void SceneSwitcher::on_mediaDown_clicked()
-{
-	int index = ui->mediaSwitches->currentRow();
-	if (index != -1 && index != ui->mediaSwitches->count() - 1) {
-		ui->mediaSwitches->insertItem(
-			index + 1, ui->mediaSwitches->takeItem(index));
-		ui->mediaSwitches->setCurrentRow(index + 1);
-
-		std::lock_guard<std::mutex> lock(switcher->m);
-
-		iter_swap(switcher->mediaSwitches.begin() + index,
-			  switcher->mediaSwitches.begin() + index + 1);
-	}
-}
-
-void SceneSwitcher::on_mediaTimeRestrictions_currentIndexChanged(int idx)
-{
-	if (idx == -1)
+	if (!listMoveUp(ui->mediaSwitches)) {
 		return;
-
-	if ((time_restriction)ui->mediaTimeRestrictions->currentIndex() ==
-	    TIME_RESTRICTION_NONE) {
-		ui->mediaTime->setDisabled(true);
-	} else {
-		ui->mediaTime->setDisabled(false);
 	}
+
+	MediaSwitchWidget *s1 =
+		(MediaSwitchWidget *)ui->mediaSwitches->itemWidget(
+			ui->mediaSwitches->item(index));
+	MediaSwitchWidget *s2 =
+		(MediaSwitchWidget *)ui->mediaSwitches->itemWidget(
+			ui->mediaSwitches->item(index - 1));
+	MediaSwitchWidget::swapSwitchData(s1, s2);
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+
+	std::swap(switcher->mediaSwitches[index],
+		  switcher->mediaSwitches[index - 1]);
+}
+
+void AdvSceneSwitcher::on_mediaDown_clicked()
+{
+	int index = ui->mediaSwitches->currentRow();
+
+	if (!listMoveDown(ui->mediaSwitches)) {
+		return;
+	}
+
+	MediaSwitchWidget *s1 =
+		(MediaSwitchWidget *)ui->mediaSwitches->itemWidget(
+			ui->mediaSwitches->item(index));
+	MediaSwitchWidget *s2 =
+		(MediaSwitchWidget *)ui->mediaSwitches->itemWidget(
+			ui->mediaSwitches->item(index + 1));
+	MediaSwitchWidget::swapSwitchData(s1, s2);
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+
+	std::swap(switcher->mediaSwitches[index],
+		  switcher->mediaSwitches[index + 1]);
 }
 
 void SwitcherData::checkMediaSwitch(bool &match, OBSWeakSource &scene,
 				    OBSWeakSource &transition)
 {
+	if (MediaSwitch::pause) {
+		return;
+	}
+
 	for (MediaSwitch &mediaSwitch : mediaSwitches) {
+		if (!mediaSwitch.initialized()) {
+			continue;
+		}
+
 		obs_source_t *source =
 			obs_weak_source_get_source(mediaSwitch.source);
 		auto duration = obs_source_media_get_duration(source);
 		auto time = obs_source_media_get_time(source);
 		obs_media_state state = obs_source_media_get_state(source);
-		bool matched =
-			state == mediaSwitch.state &&
-			(mediaSwitch.restriction == TIME_RESTRICTION_NONE ||
-			 (mediaSwitch.restriction == TIME_RESTRICTION_LONGER &&
-			  time > mediaSwitch.time) ||
-			 (mediaSwitch.restriction == TIME_RESTRICTION_SHORTER &&
-			  time < mediaSwitch.time) ||
-			 (mediaSwitch.restriction ==
-				  TIME_RESTRICTION_REMAINING_SHORTER &&
-			  duration > time &&
-			  duration - time < mediaSwitch.time) ||
-			 (mediaSwitch.restriction ==
-				  TIME_RESTRICTION_REMAINING_LONGER &&
-			  duration > time &&
-			  duration - time > mediaSwitch.time));
+		obs_source_release(source);
+
+		bool matchedStopped = mediaSwitch.state ==
+					      OBS_MEDIA_STATE_STOPPED &&
+				      mediaSwitch.stopped;
+
+		// The signal for the state ended is intentionally not used here
+		// so matchedEnded can be used to specify the end of a VLC playlist
+		// by two consequtive matches of OBS_MEDIA_STATE_ENDED
+		//
+		// This was done to reduce the likelyhood of interpreting a single
+		// OBS_MEDIA_STATE_ENDED caught by obs_source_media_get_state()
+		// as the end of the playlist of the VLC source, while actually being
+		// in the middle of switching to the next item of the playlist
+		//
+		// If there is a separate obs_media_sate in the future for the
+		// "end of playlist reached" signal the line below can be used
+		// and an additional check for this new singal can be introduced
+		//
+		// bool matchedEnded = mediaSwitch.state == OBS_MEDIA_STATE_ENDED &&
+		//		    mediaSwitch.ended;
+
+		bool ended = false;
+
+		if (state == OBS_MEDIA_STATE_ENDED) {
+			ended = mediaSwitch.previousStateEnded;
+			mediaSwitch.previousStateEnded = true;
+		} else {
+			mediaSwitch.previousStateEnded = false;
+		}
+
+		bool matchedEnded =
+			ended && (mediaSwitch.state == OBS_MEDIA_STATE_ENDED);
+
+		// match if playedToEnd was true in last interval
+		// and playback is currently ended
+		bool matchedPlayedToEnd = mediaSwitch.state ==
+						  media_played_to_end_idx &&
+					  mediaSwitch.playedToEnd && ended;
+
+		// interval * 2 to make sure not to miss any state changes
+		// which happened during check of the conditions
+		mediaSwitch.playedToEnd = mediaSwitch.playedToEnd ||
+					  (duration - time <= interval * 2);
+
+		// reset
+		if (ended) {
+			mediaSwitch.playedToEnd = false;
+		}
+
+		// reset for next check
+		mediaSwitch.stopped = false;
+		mediaSwitch.ended = false;
+
+		bool matchedState = ((state == mediaSwitch.state) ||
+				     mediaSwitch.anyState) ||
+				    matchedStopped || matchedEnded ||
+				    matchedPlayedToEnd;
+
+		bool matchedTimeNone =
+			(mediaSwitch.restriction == TIME_RESTRICTION_NONE);
+		bool matchedTimeLonger =
+			(mediaSwitch.restriction == TIME_RESTRICTION_LONGER) &&
+			(time > mediaSwitch.time);
+		bool matchedTimeShorter =
+			(mediaSwitch.restriction == TIME_RESTRICTION_SHORTER) &&
+			(time < mediaSwitch.time);
+		bool matchedTimeRemainLonger =
+			(mediaSwitch.restriction ==
+			 TIME_RESTRICTION_REMAINING_LONGER) &&
+			(duration > time && duration - time > mediaSwitch.time);
+		bool matchedTimeRemainShorter =
+			(mediaSwitch.restriction ==
+			 TIME_RESTRICTION_REMAINING_SHORTER) &&
+			(duration > time && duration - time < mediaSwitch.time);
+
+		bool matchedTime = matchedTimeNone || matchedTimeLonger ||
+				   matchedTimeShorter ||
+				   matchedTimeRemainLonger ||
+				   matchedTimeRemainShorter;
+
+		bool matched = matchedState && matchedTime;
+
 		if (matched && !mediaSwitch.matched) {
 			match = true;
-			scene = (mediaSwitch.usePreviousScene)
-					? previousScene
-					: mediaSwitch.scene;
+			scene = mediaSwitch.getScene();
 			transition = mediaSwitch.transition;
 
-			if (verbose)
+			if (verbose) {
 				mediaSwitch.logMatch();
+			}
 		}
+
 		mediaSwitch.matched = matched;
-		obs_source_release(source);
+
+		if (match) {
+			break;
+		}
 	}
 }
 
@@ -179,33 +204,8 @@ void SwitcherData::saveMediaSwitches(obs_data_t *obj)
 	for (MediaSwitch &s : switcher->mediaSwitches) {
 		obs_data_t *array_obj = obs_data_create();
 
-		obs_source_t *source = obs_weak_source_get_source(s.source);
-		obs_source_t *sceneSource = obs_weak_source_get_source(s.scene);
-		obs_source_t *transition =
-			obs_weak_source_get_source(s.transition);
-		if ((s.usePreviousScene || sceneSource) && source &&
-		    transition) {
-			const char *sourceName = obs_source_get_name(source);
-			const char *sceneName =
-				obs_source_get_name(sceneSource);
-			const char *transitionName =
-				obs_source_get_name(transition);
-			obs_data_set_string(array_obj, "source", sourceName);
-			obs_data_set_string(array_obj, "scene",
-					    s.usePreviousScene
-						    ? previous_scene_name
-						    : sceneName);
-			obs_data_set_string(array_obj, "transition",
-					    transitionName);
-			obs_data_set_int(array_obj, "state", s.state);
-			obs_data_set_int(array_obj, "restriction",
-					 s.restriction);
-			obs_data_set_int(array_obj, "time", s.time);
-			obs_data_array_push_back(mediaArray, array_obj);
-		}
-		obs_source_release(source);
-		obs_source_release(sceneSource);
-		obs_source_release(transition);
+		s.save(array_obj);
+		obs_data_array_push_back(mediaArray, array_obj);
 
 		obs_data_release(array_obj);
 	}
@@ -222,124 +222,371 @@ void SwitcherData::loadMediaSwitches(obs_data_t *obj)
 	for (size_t i = 0; i < count; i++) {
 		obs_data_t *array_obj = obs_data_array_item(mediaArray, i);
 
-		const char *source = obs_data_get_string(array_obj, "source");
-		const char *scene = obs_data_get_string(array_obj, "scene");
-		const char *transition =
-			obs_data_get_string(array_obj, "transition");
-		obs_media_state state =
-			(obs_media_state)obs_data_get_int(array_obj, "state");
-		time_restriction restriction =
-			(time_restriction)obs_data_get_int(array_obj,
-							   "restriction");
-		uint64_t time = obs_data_get_int(array_obj, "time");
-
-		std::string mediaStr = MakeMediaSwitchName(source, scene,
-							   transition, state,
-							   restriction, time)
-					       .toUtf8()
-					       .constData();
-
-		switcher->mediaSwitches.emplace_back(
-			GetWeakSourceByName(scene), GetWeakSourceByName(source),
-			GetWeakTransitionByName(transition), state, restriction,
-			time, (strcmp(scene, previous_scene_name) == 0),
-			mediaStr);
+		switcher->mediaSwitches.emplace_back();
+		mediaSwitches.back().load(array_obj);
 
 		obs_data_release(array_obj);
 	}
 	obs_data_array_release(mediaArray);
 }
 
-void SceneSwitcher::setupMediaTab()
+void AdvSceneSwitcher::setupMediaTab()
 {
-	populateSceneSelection(ui->mediaScenes, true);
-	populateTransitionSelection(ui->mediaTransitions);
-
-	auto sourceEnum = [](void *data, obs_source_t *source) -> bool /* -- */
-	{
-		QComboBox *combo = reinterpret_cast<QComboBox *>(data);
-		std::string sourceId = obs_source_get_id(source);
-		if (sourceId.compare("ffmpeg_source") == 0 ||
-		    sourceId.compare("vlc_source") == 0) {
-			const char *name = obs_source_get_name(source);
-			combo->addItem(name);
-		}
-		return true;
-	};
-
-	obs_enum_sources(sourceEnum, ui->mediaSources);
-
-	ui->mediaStates->addItem("None");
-	ui->mediaStates->addItem("Playing");
-	ui->mediaStates->addItem("Opening");
-	ui->mediaStates->addItem("Buffering");
-	ui->mediaStates->addItem("Paused");
-	ui->mediaStates->addItem("Stopped");
-	ui->mediaStates->addItem("Ended");
-	ui->mediaStates->addItem("Error");
-
-	ui->mediaTimeRestrictions->addItem("None");
-	ui->mediaTimeRestrictions->addItem("Time shorter");
-	ui->mediaTimeRestrictions->addItem("Time longer");
-	ui->mediaTimeRestrictions->addItem("Time remaining shorter");
-	ui->mediaTimeRestrictions->addItem("Time remaining longer");
-
 	for (auto &s : switcher->mediaSwitches) {
-		std::string sourceName = GetWeakSourceName(s.source);
-		std::string sceneName = (s.usePreviousScene)
-						? previous_scene_name
-						: GetWeakSourceName(s.scene);
-		std::string transitionName = GetWeakSourceName(s.transition);
-		QString listText = MakeMediaSwitchName(
-			sourceName.c_str(), sceneName.c_str(),
-			transitionName.c_str(), s.state, s.restriction, s.time);
+		QListWidgetItem *item;
+		item = new QListWidgetItem(ui->mediaSwitches);
+		ui->mediaSwitches->addItem(item);
+		MediaSwitchWidget *sw = new MediaSwitchWidget(this, &s);
+		item->setSizeHint(sw->minimumSizeHint());
+		ui->mediaSwitches->setItemWidget(item, sw);
+	}
 
-		QListWidgetItem *item =
-			new QListWidgetItem(listText, ui->mediaSwitches);
-		item->setData(Qt::UserRole, listText);
+	if (switcher->mediaSwitches.size() == 0) {
+		addPulse = PulseWidget(ui->mediaAdd, QColor(Qt::green));
+		ui->mediaHelp->setVisible(true);
+	} else {
+		ui->mediaHelp->setVisible(false);
 	}
 }
 
-static inline QString
-MakeMediaSwitchName(const QString &source, const QString &scene,
-		    const QString &transition, obs_media_state state,
-		    time_restriction restriction, uint64_t time)
+bool MediaSwitch::initialized()
 {
-	QString switchName = QStringLiteral("Switch to ") + scene +
-			     QStringLiteral(" using ") + transition +
-			     QStringLiteral(" if ") + source +
-			     QStringLiteral(" state is ");
-	if (state == OBS_MEDIA_STATE_NONE) {
-		switchName += QStringLiteral("none");
-	} else if (state == OBS_MEDIA_STATE_PLAYING) {
-		switchName += QStringLiteral("playing");
-	} else if (state == OBS_MEDIA_STATE_OPENING) {
-		switchName += QStringLiteral("opening");
-	} else if (state == OBS_MEDIA_STATE_BUFFERING) {
-		switchName += QStringLiteral("buffering");
-	} else if (state == OBS_MEDIA_STATE_PAUSED) {
-		switchName += QStringLiteral("paused");
-	} else if (state == OBS_MEDIA_STATE_STOPPED) {
-		switchName += QStringLiteral("stopped");
-	} else if (state == OBS_MEDIA_STATE_ENDED) {
-		switchName += QStringLiteral("ended");
-	} else if (state == OBS_MEDIA_STATE_ERROR) {
-		switchName += QStringLiteral("error");
-	}
-	if (restriction == TIME_RESTRICTION_SHORTER) {
-		switchName += QStringLiteral(" and time shorter than ");
-	} else if (restriction == TIME_RESTRICTION_LONGER) {
-		switchName += QStringLiteral(" and time longer than ");
-	} else if (restriction == TIME_RESTRICTION_REMAINING_SHORTER) {
-		switchName +=
-			QStringLiteral(" and time remaining shorter than ");
-	} else if (restriction == TIME_RESTRICTION_REMAINING_LONGER) {
-		switchName +=
-			QStringLiteral(" and time remaining longer than ");
-	}
-	if (restriction != TIME_RESTRICTION_NONE) {
-		switchName += std::to_string(time).c_str();
-		switchName += QStringLiteral(" ms");
-	}
-	return switchName;
+	return SceneSwitcherEntry::initialized() && source;
+}
+
+bool MediaSwitch::valid()
+{
+	return !initialized() ||
+	       (SceneSwitcherEntry::valid() && WeakSourceValid(source));
+}
+
+void MediaSwitch::save(obs_data_t *obj)
+{
+	SceneSwitcherEntry::save(obj);
+
+	obs_data_set_string(obj, "source", GetWeakSourceName(source).c_str());
+
+	obs_data_set_int(obj, "state", state);
+	obs_data_set_int(obj, "restriction", restriction);
+	obs_data_set_int(obj, "time", time);
+}
+
+// To be removed in future version
+bool loadOldMedia(obs_data_t *obj, MediaSwitch *s)
+{
+	if (!s) {
+		return false;
+	}
+
+	const char *scene = obs_data_get_string(obj, "scene");
+
+	if (strcmp(scene, "") == 0) {
+		return false;
+	}
+
+	s->scene = GetWeakSourceByName(scene);
+
+	const char *transition = obs_data_get_string(obj, "transition");
+	s->transition = GetWeakTransitionByName(transition);
+
+	const char *source = obs_data_get_string(obj, "source");
+	s->source = GetWeakSourceByName(source);
+
+	s->state = (obs_media_state)obs_data_get_int(obj, "state");
+	s->restriction = (time_restriction)obs_data_get_int(obj, "restriction");
+	s->time = obs_data_get_int(obj, "time");
+	s->usePreviousScene = strcmp(scene, previous_scene_name) == 0;
+
+	return true;
+}
+
+void MediaSwitch::load(obs_data_t *obj)
+{
+
+	if (loadOldMedia(obj, this)) {
+		return;
+	}
+
+	SceneSwitcherEntry::load(obj);
+
+	const char *sourceName = obs_data_get_string(obj, "source");
+	source = GetWeakSourceByName(sourceName);
+
+	state = (obs_media_state)obs_data_get_int(obj, "state");
+	restriction = (time_restriction)obs_data_get_int(obj, "restriction");
+	time = obs_data_get_int(obj, "time");
+
+	anyState = state == media_any_idx;
+	obs_source_t *mediasource = obs_weak_source_get_source(source);
+	signal_handler_t *sh = obs_source_get_signal_handler(mediasource);
+	signal_handler_connect(sh, "media_stopped", MediaStopped, this);
+	signal_handler_connect(sh, "media_ended", MediaEnded, this);
+	obs_source_release(mediasource);
+}
+
+void MediaSwitch::clearSignalHandler()
+{
+	obs_source_t *mediasource = obs_weak_source_get_source(source);
+	signal_handler_t *sh = obs_source_get_signal_handler(mediasource);
+	signal_handler_disconnect(sh, "media_stopped", MediaStopped, this);
+	signal_handler_disconnect(sh, "media_ended", MediaEnded, this);
+	obs_source_release(mediasource);
+}
+
+void MediaSwitch::resetSignalHandler()
+{
+	obs_source_t *mediasource = obs_weak_source_get_source(source);
+	signal_handler_t *sh = obs_source_get_signal_handler(mediasource);
+	signal_handler_disconnect(sh, "media_stopped", MediaStopped, this);
+	signal_handler_disconnect(sh, "media_ended", MediaEnded, this);
+	signal_handler_connect(sh, "media_stopped", MediaStopped, this);
+	signal_handler_connect(sh, "media_ended", MediaEnded, this);
+	obs_source_release(mediasource);
+}
+
+void MediaSwitch::MediaStopped(void *data, calldata_t *)
+{
+	MediaSwitch *media = static_cast<MediaSwitch *>(data);
+	media->stopped = true;
+}
+
+void MediaSwitch::MediaEnded(void *data, calldata_t *)
+{
+	MediaSwitch *media = static_cast<MediaSwitch *>(data);
+	media->ended = true;
+}
+
+MediaSwitch::MediaSwitch(const MediaSwitch &other)
+	: SceneSwitcherEntry(other.targetType, other.group, other.scene,
+			     other.transition, other.usePreviousScene),
+	  source(other.source),
+	  state(other.state),
+	  restriction(other.restriction),
+	  time(other.time)
+{
+	anyState = state == media_any_idx;
+	obs_source_t *mediasource = obs_weak_source_get_source(source);
+	signal_handler_t *sh = obs_source_get_signal_handler(mediasource);
+	signal_handler_connect(sh, "media_stopped", MediaStopped, this);
+	signal_handler_connect(sh, "media_ended", MediaEnded, this);
+	obs_source_release(mediasource);
+}
+
+MediaSwitch::MediaSwitch(MediaSwitch &&other)
+	: SceneSwitcherEntry(other.targetType, other.group, other.scene,
+			     other.transition, other.usePreviousScene),
+	  source(other.source),
+	  state(other.state),
+	  anyState(other.anyState),
+	  restriction(other.restriction),
+	  time(other.time)
+{
+}
+
+MediaSwitch::~MediaSwitch()
+{
+	obs_source_t *mediasource = obs_weak_source_get_source(source);
+	signal_handler_t *sh = obs_source_get_signal_handler(mediasource);
+	signal_handler_disconnect(sh, "media_stopped", MediaStopped, this);
+	signal_handler_disconnect(sh, "media_ended", MediaEnded, this);
+	obs_source_release(mediasource);
+}
+
+MediaSwitch &MediaSwitch::operator=(const MediaSwitch &other)
+{
+	MediaSwitch t(other);
+	swap(*this, t);
+	return *this = MediaSwitch(other);
+}
+
+MediaSwitch &MediaSwitch::operator=(MediaSwitch &&other) noexcept
+{
+	if (this == &other) {
+		return *this;
+	}
+
+	swap(*this, other);
+
+	obs_source_t *mediasource = obs_weak_source_get_source(other.source);
+	signal_handler_t *sh = obs_source_get_signal_handler(mediasource);
+	signal_handler_disconnect(sh, "media_stopped", MediaStopped, &other);
+	signal_handler_disconnect(sh, "media_ended", MediaEnded, &other);
+	obs_source_release(mediasource);
+
+	return *this;
+}
+
+void swap(MediaSwitch &first, MediaSwitch &second)
+{
+	std::swap(first.targetType, second.targetType);
+	std::swap(first.group, second.group);
+	std::swap(first.scene, second.scene);
+	std::swap(first.transition, second.transition);
+	std::swap(first.usePreviousScene, second.usePreviousScene);
+	std::swap(first.source, second.source);
+	std::swap(first.state, second.state);
+	std::swap(first.restriction, second.restriction);
+	std::swap(first.time, second.time);
+	std::swap(first.anyState, second.anyState);
+	first.resetSignalHandler();
+	second.resetSignalHandler();
+}
+
+void populateMediaStates(QComboBox *list)
+{
+	list->addItem(obs_module_text("AdvSceneSwitcher.mediaTab.states.none"));
+	list->addItem(
+		obs_module_text("AdvSceneSwitcher.mediaTab.states.playing"));
+	list->addItem(
+		obs_module_text("AdvSceneSwitcher.mediaTab.states.opening"));
+	list->addItem(
+		obs_module_text("AdvSceneSwitcher.mediaTab.states.buffering"));
+	list->addItem(
+		obs_module_text("AdvSceneSwitcher.mediaTab.states.paused"));
+	list->addItem(
+		obs_module_text("AdvSceneSwitcher.mediaTab.states.stopped"));
+	list->addItem(
+		obs_module_text("AdvSceneSwitcher.mediaTab.states.ended"));
+	list->addItem(
+		obs_module_text("AdvSceneSwitcher.mediaTab.states.error"));
+	list->addItem(obs_module_text(
+		"AdvSceneSwitcher.mediaTab.states.playedToEnd"));
+	list->addItem(obs_module_text("AdvSceneSwitcher.mediaTab.states.any"));
+}
+
+void populateTimeRestrictions(QComboBox *list)
+{
+	list->addItem(obs_module_text(
+		"AdvSceneSwitcher.mediaTab.timeRestriction.none"));
+	list->addItem(obs_module_text(
+		"AdvSceneSwitcher.mediaTab.timeRestriction.shorter"));
+	list->addItem(obs_module_text(
+		"AdvSceneSwitcher.mediaTab.timeRestriction.longer"));
+	list->addItem(obs_module_text(
+		"AdvSceneSwitcher.mediaTab.timeRestriction.remainShorter"));
+	list->addItem(obs_module_text(
+		"AdvSceneSwitcher.mediaTab.timeRestriction.remainLonger"));
+}
+
+MediaSwitchWidget::MediaSwitchWidget(QWidget *parent, MediaSwitch *s)
+	: SwitchWidget(parent, s, true, true)
+{
+	mediaSources = new QComboBox();
+	states = new QComboBox();
+	timeRestrictions = new QComboBox();
+	time = new QSpinBox();
+
+	time->setSuffix("ms");
+	time->setMaximum(99999999);
+	time->setMinimum(0);
+
+	QWidget::connect(mediaSources,
+			 SIGNAL(currentTextChanged(const QString &)), this,
+			 SLOT(SourceChanged(const QString &)));
+	QWidget::connect(states, SIGNAL(currentIndexChanged(int)), this,
+			 SLOT(StateChanged(int)));
+	QWidget::connect(timeRestrictions, SIGNAL(currentIndexChanged(int)),
+			 this, SLOT(TimeRestrictionChanged(int)));
+	QWidget::connect(time, SIGNAL(valueChanged(int)), this,
+			 SLOT(TimeChanged(int)));
+
+	AdvSceneSwitcher::populateMediaSelection(mediaSources);
+	populateMediaStates(states);
+	populateTimeRestrictions(timeRestrictions);
+
+	if (s) {
+		mediaSources->setCurrentText(
+			GetWeakSourceName(s->source).c_str());
+		states->setCurrentIndex(s->state);
+		timeRestrictions->setCurrentIndex(s->restriction);
+		time->setValue(s->time);
+		if (s->restriction == TIME_RESTRICTION_NONE) {
+			time->setDisabled(true);
+		}
+	}
+
+	QHBoxLayout *mainLayout = new QHBoxLayout;
+	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
+		{"{{mediaSources}}", mediaSources},
+		{"{{states}}", states},
+		{"{{timeRestrictions}}", timeRestrictions},
+		{"{{time}}", time},
+		{"{{scenes}}", scenes},
+		{"{{transitions}}", transitions}};
+	placeWidgets(obs_module_text("AdvSceneSwitcher.mediaTab.entry"),
+		     mainLayout, widgetPlaceholders);
+	setLayout(mainLayout);
+
+	switchData = s;
+
+	loading = false;
+}
+
+MediaSwitch *MediaSwitchWidget::getSwitchData()
+{
+	return switchData;
+}
+
+void MediaSwitchWidget::setSwitchData(MediaSwitch *s)
+{
+	switchData = s;
+}
+
+void MediaSwitchWidget::swapSwitchData(MediaSwitchWidget *s1,
+				       MediaSwitchWidget *s2)
+{
+	SwitchWidget::swapSwitchData(s1, s2);
+
+	MediaSwitch *t = s1->getSwitchData();
+	s1->setSwitchData(s2->getSwitchData());
+	s2->setSwitchData(t);
+}
+
+void MediaSwitchWidget::SourceChanged(const QString &text)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->clearSignalHandler();
+	switchData->source = GetWeakSourceByQString(text);
+	switchData->resetSignalHandler();
+}
+
+void MediaSwitchWidget::StateChanged(int index)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->state = (obs_media_state)index;
+	switchData->anyState = switchData->state == media_any_idx;
+}
+
+void MediaSwitchWidget::TimeRestrictionChanged(int index)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	if ((time_restriction)index == TIME_RESTRICTION_NONE) {
+		time->setDisabled(true);
+	} else {
+		time->setDisabled(false);
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->restriction = (time_restriction)index;
+}
+
+void MediaSwitchWidget::TimeChanged(int time)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->time = time;
 }

src/switch-pause.cpp

@@ -1,266 +1,262 @@
 #include <regex>
 
 #include "headers/advanced-scene-switcher.hpp"
+#include "headers/utility.hpp"
 
-void SceneSwitcher::on_pauseScenesAdd_clicked()
+static QMetaObject::Connection addPulse;
+
+void AdvSceneSwitcher::on_pauseAdd_clicked()
 {
-	QString sceneName = ui->pauseScenesScenes->currentText();
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switcher->pauseEntries.emplace_back();
 
-	if (sceneName.isEmpty())
-		return;
+	listAddClicked(ui->pauseEntries,
+		       new PauseEntryWidget(this,
+					    &switcher->pauseEntries.back()),
+		       ui->pauseAdd, &addPulse);
 
-	OBSWeakSource source = GetWeakSourceByQString(sceneName);
-	QVariant v = QVariant::fromValue(sceneName);
-
-	QList<QListWidgetItem *> items =
-		ui->pauseScenes->findItems(sceneName, Qt::MatchExactly);
-
-	if (items.size() == 0) {
-		QListWidgetItem *item =
-			new QListWidgetItem(sceneName, ui->pauseScenes);
-		item->setData(Qt::UserRole, v);
-
-		std::lock_guard<std::mutex> lock(switcher->m);
-		switcher->pauseScenesSwitches.emplace_back(source);
-		ui->pauseScenes->sortItems();
-	}
+	ui->pauseHelp->setVisible(false);
 }
 
-void SceneSwitcher::on_pauseScenesRemove_clicked()
+void AdvSceneSwitcher::on_pauseRemove_clicked()
 {
-	QListWidgetItem *item = ui->pauseScenes->currentItem();
-	if (!item)
+	QListWidgetItem *item = ui->pauseEntries->currentItem();
+	if (!item) {
 		return;
-
-	QString pauseScene = item->data(Qt::UserRole).toString();
+	}
 
 	{
 		std::lock_guard<std::mutex> lock(switcher->m);
-		auto &switches = switcher->pauseScenesSwitches;
-
-		for (auto it = switches.begin(); it != switches.end(); ++it) {
-			auto &s = *it;
-
-			if (s == GetWeakSourceByQString(pauseScene)) {
-				switches.erase(it);
-				break;
-			}
-		}
+		int idx = ui->pauseEntries->currentRow();
+		auto &switches = switcher->pauseEntries;
+		switches.erase(switches.begin() + idx);
 	}
 
 	delete item;
 }
 
-void SceneSwitcher::on_pauseWindowsAdd_clicked()
+void AdvSceneSwitcher::on_pauseUp_clicked()
 {
-	QString windowName = ui->pauseWindowsWindows->currentText();
-
-	if (windowName.isEmpty())
+	int index = ui->pauseEntries->currentRow();
+	if (!listMoveUp(ui->pauseEntries)) {
 		return;
-
-	QVariant v = QVariant::fromValue(windowName);
-
-	QList<QListWidgetItem *> items =
-		ui->pauseWindows->findItems(windowName, Qt::MatchExactly);
-
-	if (items.size() == 0) {
-		QListWidgetItem *item =
-			new QListWidgetItem(windowName, ui->pauseWindows);
-		item->setData(Qt::UserRole, v);
-
-		std::lock_guard<std::mutex> lock(switcher->m);
-		switcher->pauseWindowsSwitches.emplace_back(
-			windowName.toUtf8().constData());
-		ui->pauseWindows->sortItems();
-	}
-}
-
-void SceneSwitcher::on_pauseWindowsRemove_clicked()
-{
-	QListWidgetItem *item = ui->pauseWindows->currentItem();
-	if (!item)
-		return;
-
-	QString windowName = item->data(Qt::UserRole).toString();
-
-	{
-		std::lock_guard<std::mutex> lock(switcher->m);
-		auto &switches = switcher->pauseWindowsSwitches;
-
-		for (auto it = switches.begin(); it != switches.end(); ++it) {
-			auto &s = *it;
-
-			if (s == windowName.toUtf8().constData()) {
-				switches.erase(it);
-				break;
-			}
-		}
 	}
 
-	delete item;
-}
-
-void SceneSwitcher::on_pauseScenes_currentRowChanged(int idx)
-{
-	if (loading)
-		return;
-	if (idx == -1)
-		return;
-
-	QListWidgetItem *item = ui->pauseScenes->item(idx);
-
-	QString scene = item->data(Qt::UserRole).toString();
+	PauseEntryWidget *s1 = (PauseEntryWidget *)ui->pauseEntries->itemWidget(
+		ui->pauseEntries->item(index));
+	PauseEntryWidget *s2 = (PauseEntryWidget *)ui->pauseEntries->itemWidget(
+		ui->pauseEntries->item(index - 1));
+	PauseEntryWidget::swapSwitchData(s1, s2);
 
 	std::lock_guard<std::mutex> lock(switcher->m);
-	for (auto &s : switcher->pauseScenesSwitches) {
-		std::string name = GetWeakSourceName(s);
-		if (scene.compare(name.c_str()) == 0) {
-			ui->pauseScenesScenes->setCurrentText(name.c_str());
-			break;
-		}
-	}
+
+	std::swap(switcher->pauseEntries[index],
+		  switcher->pauseEntries[index - 1]);
 }
 
-void SceneSwitcher::on_pauseWindows_currentRowChanged(int idx)
+void AdvSceneSwitcher::on_pauseDown_clicked()
 {
-	if (loading)
-		return;
-	if (idx == -1)
-		return;
+	int index = ui->pauseEntries->currentRow();
 
-	QListWidgetItem *item = ui->pauseWindows->item(idx);
+	if (!listMoveDown(ui->pauseEntries)) {
+		return;
+	}
 
-	QString window = item->data(Qt::UserRole).toString();
+	PauseEntryWidget *s1 = (PauseEntryWidget *)ui->pauseEntries->itemWidget(
+		ui->pauseEntries->item(index));
+	PauseEntryWidget *s2 = (PauseEntryWidget *)ui->pauseEntries->itemWidget(
+		ui->pauseEntries->item(index + 1));
+	PauseEntryWidget::swapSwitchData(s1, s2);
 
 	std::lock_guard<std::mutex> lock(switcher->m);
-	for (auto &s : switcher->pauseWindowsSwitches) {
-		if (window.compare(s.c_str()) == 0) {
-			ui->pauseWindowsWindows->setCurrentText(s.c_str());
-			break;
-		}
+
+	std::swap(switcher->pauseEntries[index],
+		  switcher->pauseEntries[index + 1]);
+}
+
+void resetPause()
+{
+	DefaultSceneTransition::pause = false;
+	WindowSwitch::pause = false;
+	ExecutableSwitch::pause = false;
+	ScreenRegionSwitch::pause = false;
+	MediaSwitch::pause = false;
+	FileSwitch::pause = false;
+	RandomSwitch::pause = false;
+	TimeSwitch::pause = false;
+	IdleData::pause = false;
+	SceneSequenceSwitch::pause = false;
+	AudioSwitch::pause = false;
+}
+
+void setPauseTarget(PauseTarget &target, bool &verbose)
+{
+	switch (target) {
+	case PauseTarget::All:
+		vblog(LOG_INFO, "pause all switching");
+		break;
+	case PauseTarget::Transition:
+		vblog(LOG_INFO, "pause def_transition switching");
+		DefaultSceneTransition::pause = true;
+		break;
+	case PauseTarget::Window:
+		vblog(LOG_INFO, "pause window switching");
+		WindowSwitch::pause = true;
+		break;
+	case PauseTarget::Executable:
+		vblog(LOG_INFO, "pause exec switching");
+		ExecutableSwitch::pause = true;
+		break;
+	case PauseTarget::Region:
+		vblog(LOG_INFO, "pause region switching");
+		ScreenRegionSwitch::pause = true;
+		break;
+	case PauseTarget::Media:
+		vblog(LOG_INFO, "pause media switching");
+		MediaSwitch::pause = true;
+		break;
+	case PauseTarget::File:
+		vblog(LOG_INFO, "pause file switching");
+		FileSwitch::pause = true;
+		break;
+	case PauseTarget::Random:
+		vblog(LOG_INFO, "pause random switching");
+		RandomSwitch::pause = true;
+		break;
+	case PauseTarget::Time:
+		vblog(LOG_INFO, "pause time switching");
+		TimeSwitch::pause = true;
+		break;
+	case PauseTarget::Idle:
+		vblog(LOG_INFO, "pause idle switching");
+		IdleData::pause = true;
+		break;
+	case PauseTarget::Sequence:
+		vblog(LOG_INFO, "pause sequence switching");
+		SceneSequenceSwitch::pause = true;
+		break;
+	case PauseTarget::Audio:
+		vblog(LOG_INFO, "pause audio switching");
+		AudioSwitch::pause = true;
+		break;
 	}
 }
 
-int SceneSwitcher::PauseScenesFindByData(const QString &scene)
+bool checkPauseScene(obs_weak_source_t *currentScene, obs_weak_source_t *scene,
+		     PauseTarget &target, bool &verbose)
 {
-	int count = ui->pauseScenes->count();
-	int idx = -1;
-
-	for (int i = 0; i < count; i++) {
-		QListWidgetItem *item = ui->pauseScenes->item(i);
-		QString itemRegion = item->data(Qt::UserRole).toString();
-
-		if (itemRegion == scene) {
-			idx = i;
-			break;
-		}
+	if (currentScene != scene) {
+		return false;
 	}
 
-	return idx;
+	setPauseTarget(target, verbose);
+	return (target == PauseTarget::All);
 }
-
-int SceneSwitcher::PauseWindowsFindByData(const QString &window)
+bool checkPauseWindow(std::string &currentTitle, std::string &title,
+		      PauseTarget &target, bool &verbose)
 {
-	int count = ui->pauseWindows->count();
-	int idx = -1;
-
-	for (int i = 0; i < count; i++) {
-		QListWidgetItem *item = ui->pauseWindows->item(i);
-		QString itemRegion = item->data(Qt::UserRole).toString();
-
-		if (itemRegion == window) {
-			idx = i;
-			break;
-		}
+	if (currentTitle != title) {
+		return false;
 	}
 
-	return idx;
+	setPauseTarget(target, verbose);
+	return (target == PauseTarget::All);
 }
 
 bool SwitcherData::checkPause()
 {
-	bool pause = false;
+	bool pauseAll = false;
+
+	std::string title;
+	GetCurrentWindowTitle(title);
+
+	resetPause();
+
 	obs_source_t *currentSource = obs_frontend_get_current_scene();
 	obs_weak_source_t *ws = obs_source_get_weak_source(currentSource);
 
-	for (OBSWeakSource &s : pauseScenesSwitches) {
-		if (s == ws) {
-			pause = true;
+	for (PauseEntry &s : pauseEntries) {
+		if (s.pauseType == PauseType::Scene) {
+			pauseAll = checkPauseScene(ws, s.scene, s.pauseTarget,
+						   verbose);
+		} else {
+			pauseAll = checkPauseWindow(title, s.window,
+						    s.pauseTarget, verbose);
+		}
+		if (pauseAll) {
 			break;
 		}
 	}
+
 	obs_source_release(currentSource);
 	obs_weak_source_release(ws);
 
-	std::string title;
-	if (!pause) {
-		//lock.unlock();
-		GetCurrentWindowTitle(title);
-		//lock.lock();
-		for (std::string &window : pauseWindowsSwitches) {
-			if (window == title) {
-				pause = true;
-				break;
-			}
-		}
-	}
-
-	if (!pause) {
-		//lock.unlock();
-		GetCurrentWindowTitle(title);
-		//lock.lock();
-		for (std::string &window : pauseWindowsSwitches) {
-			try {
-				bool matches = std::regex_match(
-					title, std::regex(window));
-				if (matches) {
-					pause = true;
-					break;
-				}
-			} catch (const std::regex_error &) {
-			}
-		}
-	}
-
-	if (verbose && pause)
-		blog(LOG_INFO, "Advanced Scene Switcher pause match");
-
-	return pause;
+	return pauseAll;
 }
 
 void SwitcherData::savePauseSwitches(obs_data_t *obj)
 {
 	obs_data_array_t *pauseScenesArray = obs_data_array_create();
-	for (OBSWeakSource &scene : switcher->pauseScenesSwitches) {
+	for (PauseEntry &s : switcher->pauseEntries) {
 		obs_data_t *array_obj = obs_data_create();
 
-		obs_source_t *source = obs_weak_source_get_source(scene);
+		obs_data_set_int(array_obj, "pauseType",
+				 static_cast<int>(s.pauseType));
+		obs_data_set_int(array_obj, "pauseTarget",
+				 static_cast<int>(s.pauseTarget));
+		obs_data_set_string(array_obj, "pauseWindow", s.window.c_str());
+
+		obs_source_t *source = obs_weak_source_get_source(s.scene);
 		if (source) {
 			const char *n = obs_source_get_name(source);
 			obs_data_set_string(array_obj, "pauseScene", n);
-			obs_data_array_push_back(pauseScenesArray, array_obj);
-			obs_source_release(source);
 		}
 
-		obs_data_release(array_obj);
-	}
-	obs_data_set_array(obj, "pauseScenes", pauseScenesArray);
-	obs_data_array_release(pauseScenesArray);
+		obs_data_array_push_back(pauseScenesArray, array_obj);
 
-	obs_data_array_t *pauseWindowsArray = obs_data_array_create();
-	for (std::string &window : switcher->pauseWindowsSwitches) {
-		obs_data_t *array_obj = obs_data_create();
-		obs_data_set_string(array_obj, "pauseWindow", window.c_str());
-		obs_data_array_push_back(pauseWindowsArray, array_obj);
+		obs_source_release(source);
 		obs_data_release(array_obj);
 	}
-	obs_data_set_array(obj, "pauseWindows", pauseWindowsArray);
-	obs_data_array_release(pauseWindowsArray);
+	obs_data_set_array(obj, "pauseEntries", pauseScenesArray);
+	obs_data_set_int(obj, "oldPauseValuesImported", 1);
+	obs_data_array_release(pauseScenesArray);
 }
 
 void SwitcherData::loadPauseSwitches(obs_data_t *obj)
 {
-	switcher->pauseScenesSwitches.clear();
+	switcher->pauseEntries.clear();
+
+	// To be removed in future builds once most users have migrated
+	loadOldPauseSwitches(obj);
+
+	obs_data_array_t *pauseArray = obs_data_get_array(obj, "pauseEntries");
+	size_t count = obs_data_array_count(pauseArray);
+
+	for (size_t i = 0; i < count; i++) {
+		obs_data_t *array_obj = obs_data_array_item(pauseArray, i);
+
+		PauseType type = static_cast<PauseType>(
+			obs_data_get_int(array_obj, "pauseType"));
+		PauseTarget target = static_cast<PauseTarget>(
+			obs_data_get_int(array_obj, "pauseTarget"));
+		const char *scene =
+			obs_data_get_string(array_obj, "pauseScene");
+		const char *window =
+			obs_data_get_string(array_obj, "pauseWindow");
+
+		switcher->pauseEntries.emplace_back(GetWeakSourceByName(scene),
+						    type, target, window);
+
+		obs_data_release(array_obj);
+	}
+	obs_data_array_release(pauseArray);
+}
+
+void SwitcherData::loadOldPauseSwitches(obs_data_t *obj)
+{
+	if (obs_data_get_int(obj, "oldPauseValuesImported")) {
+		return;
+	}
 
 	obs_data_array_t *pauseScenesArray =
 		obs_data_get_array(obj, "pauseScenes");
@@ -273,15 +269,14 @@ void SwitcherData::loadPauseSwitches(obs_data_t *obj)
 		const char *scene =
 			obs_data_get_string(array_obj, "pauseScene");
 
-		switcher->pauseScenesSwitches.emplace_back(
-			GetWeakSourceByName(scene));
+		switcher->pauseEntries.emplace_back(GetWeakSourceByName(scene),
+						    PauseType::Scene,
+						    PauseTarget::All, "");
 
 		obs_data_release(array_obj);
 	}
 	obs_data_array_release(pauseScenesArray);
 
-	switcher->pauseWindowsSwitches.clear();
-
 	obs_data_array_t *pauseWindowsArray =
 		obs_data_get_array(obj, "pauseWindows");
 	count = obs_data_array_count(pauseWindowsArray);
@@ -293,32 +288,174 @@ void SwitcherData::loadPauseSwitches(obs_data_t *obj)
 		const char *window =
 			obs_data_get_string(array_obj, "pauseWindow");
 
-		switcher->pauseWindowsSwitches.emplace_back(window);
+		switcher->pauseEntries.emplace_back(nullptr, PauseType::Window,
+						    PauseTarget::All, window);
 
 		obs_data_release(array_obj);
 	}
 	obs_data_array_release(pauseWindowsArray);
 }
 
-void SceneSwitcher::setupPauseTab()
+void AdvSceneSwitcher::setupPauseTab()
 {
-	populateSceneSelection(ui->pauseScenesScenes, false);
-	populateWindowSelection(ui->pauseWindowsWindows);
-
-	for (auto &scene : switcher->pauseScenesSwitches) {
-		std::string sceneName = GetWeakSourceName(scene);
-		QString text = QString::fromStdString(sceneName);
-
-		QListWidgetItem *item =
-			new QListWidgetItem(text, ui->pauseScenes);
-		item->setData(Qt::UserRole, text);
+	for (auto &s : switcher->pauseEntries) {
+		QListWidgetItem *item;
+		item = new QListWidgetItem(ui->pauseEntries);
+		ui->pauseEntries->addItem(item);
+		PauseEntryWidget *sw = new PauseEntryWidget(this, &s);
+		item->setSizeHint(sw->minimumSizeHint());
+		ui->pauseEntries->setItemWidget(item, sw);
 	}
 
-	for (auto &window : switcher->pauseWindowsSwitches) {
-		QString text = QString::fromStdString(window);
-
-		QListWidgetItem *item =
-			new QListWidgetItem(text, ui->pauseWindows);
-		item->setData(Qt::UserRole, text);
+	if (switcher->pauseEntries.size() == 0) {
+		addPulse = PulseWidget(ui->pauseAdd, QColor(Qt::green));
+		ui->pauseHelp->setVisible(true);
+	} else {
+		ui->pauseHelp->setVisible(false);
 	}
 }
+
+void populatePauseTypes(QComboBox *list)
+{
+	list->addItem(
+		obs_module_text("AdvSceneSwitcher.pauseTab.pauseTypeScene"));
+	list->addItem(
+		obs_module_text("AdvSceneSwitcher.pauseTab.pauseTypeWindow"));
+}
+
+void populatePauseTargets(QComboBox *list)
+{
+	list->addItem(
+		obs_module_text("AdvSceneSwitcher.pauseTab.pauseTargetAll"));
+	list->addItem(obs_module_text("AdvSceneSwitcher.transitionTab.title"));
+	list->addItem(obs_module_text("AdvSceneSwitcher.windowTitleTab.title"));
+	list->addItem(obs_module_text("AdvSceneSwitcher.executableTab.title"));
+	list->addItem(
+		obs_module_text("AdvSceneSwitcher.screenRegionTab.title"));
+	list->addItem(obs_module_text("AdvSceneSwitcher.mediaTab.title"));
+	list->addItem(obs_module_text("AdvSceneSwitcher.fileTab.title"));
+	list->addItem(obs_module_text("AdvSceneSwitcher.randomTab.title"));
+	list->addItem(obs_module_text("AdvSceneSwitcher.timeTab.title"));
+	list->addItem(obs_module_text("AdvSceneSwitcher.idleTab.title"));
+	list->addItem(
+		obs_module_text("AdvSceneSwitcher.sceneSequenceTab.title"));
+	list->addItem(obs_module_text("AdvSceneSwitcher.audioTab.title"));
+}
+
+PauseEntryWidget::PauseEntryWidget(QWidget *parent, PauseEntry *s)
+	: SwitchWidget(parent, s, false, false)
+{
+	pauseTypes = new QComboBox();
+	pauseTargets = new QComboBox();
+	windows = new QComboBox();
+
+	QWidget::connect(pauseTypes, SIGNAL(currentIndexChanged(int)), this,
+			 SLOT(PauseTypeChanged(int)));
+	QWidget::connect(pauseTargets, SIGNAL(currentIndexChanged(int)), this,
+			 SLOT(PauseTargetChanged(int)));
+	QWidget::connect(windows, SIGNAL(currentTextChanged(const QString &)),
+			 this, SLOT(WindowChanged(const QString &)));
+
+	populatePauseTypes(pauseTypes);
+	populatePauseTargets(pauseTargets);
+	AdvSceneSwitcher::populateWindowSelection(windows);
+
+	windows->setEditable(true);
+	windows->setMaxVisibleItems(20);
+
+	if (s) {
+		scenes->setCurrentText(GetWeakSourceName(s->scene).c_str());
+		pauseTypes->setCurrentIndex(static_cast<int>(s->pauseType));
+		pauseTargets->setCurrentIndex(static_cast<int>(s->pauseTarget));
+		windows->setCurrentText(s->window.c_str());
+		if (s->pauseType == PauseType::Scene) {
+			windows->setDisabled(true);
+			windows->setVisible(false);
+		} else {
+			scenes->setDisabled(true);
+			scenes->setVisible(false);
+		}
+	}
+
+	QHBoxLayout *mainLayout = new QHBoxLayout;
+	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
+		{"{{scenes}}", scenes},
+		{"{{pauseTypes}}", pauseTypes},
+		{"{{pauseTargets}}", pauseTargets},
+		{"{{windows}}", windows}};
+
+	placeWidgets(obs_module_text("AdvSceneSwitcher.pauseTab.pauseEntry"),
+		     mainLayout, widgetPlaceholders);
+	setLayout(mainLayout);
+
+	switchData = s;
+
+	loading = false;
+}
+
+PauseEntry *PauseEntryWidget::getSwitchData()
+{
+	return switchData;
+}
+
+void PauseEntryWidget::setSwitchData(PauseEntry *s)
+{
+	switchData = s;
+}
+
+void PauseEntryWidget::swapSwitchData(PauseEntryWidget *s1,
+				      PauseEntryWidget *s2)
+{
+	SwitchWidget::swapSwitchData(s1, s2);
+
+	PauseEntry *t = s1->getSwitchData();
+	s1->setSwitchData(s2->getSwitchData());
+	s2->setSwitchData(t);
+}
+
+void PauseEntryWidget::PauseTypeChanged(int index)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->pauseType = static_cast<PauseType>(index);
+
+	if (switchData->pauseType == PauseType::Scene) {
+		windows->setDisabled(true);
+		windows->setVisible(false);
+		scenes->setDisabled(false);
+		scenes->setVisible(true);
+	} else {
+		scenes->setDisabled(true);
+		scenes->setVisible(false);
+		windows->setDisabled(false);
+		windows->setVisible(true);
+	}
+}
+
+void PauseEntryWidget::PauseTargetChanged(int index)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->pauseTarget = static_cast<PauseTarget>(index);
+}
+
+void PauseEntryWidget::WindowChanged(const QString &text)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->window = text.toStdString();
+}
+
+bool PauseEntry::valid()
+{
+	return true;
+}

src/switch-priority.cpp

@@ -2,7 +2,7 @@
 
 #include "headers/advanced-scene-switcher.hpp"
 
-void SceneSwitcher::on_threadPriority_currentTextChanged(const QString &text)
+void AdvSceneSwitcher::on_threadPriority_currentTextChanged(const QString &text)
 {
 	if (loading || ui->threadPriority->count() !=
 			       (int)switcher->threadPriorities.size())
@@ -18,7 +18,7 @@ void SceneSwitcher::on_threadPriority_currentTextChanged(const QString &text)
 	}
 }
 
-void SceneSwitcher::on_priorityUp_clicked()
+void AdvSceneSwitcher::on_priorityUp_clicked()
 {
 	int currentIndex = ui->priorityList->currentRow();
 	if (currentIndex != -1 && currentIndex != 0) {
@@ -35,7 +35,7 @@ void SceneSwitcher::on_priorityUp_clicked()
 	}
 }
 
-void SceneSwitcher::on_priorityDown_clicked()
+void AdvSceneSwitcher::on_priorityDown_clicked()
 {
 	int currentIndex = ui->priorityList->currentRow();
 	if (currentIndex != -1 &&
@@ -58,12 +58,14 @@ bool SwitcherData::prioFuncsValid()
 	auto it = std::unique(functionNamesByPriority.begin(),
 			      functionNamesByPriority.end());
 	bool wasUnique = (it == functionNamesByPriority.end());
-	if (!wasUnique)
+	if (!wasUnique) {
 		return false;
+	}
 
 	for (int p : functionNamesByPriority) {
-		if (p < 0 || p > 8)
+		if (p < 0 || p > 8) {
 			return false;
+		}
 	}
 	return true;
 }

src/switch-random.cpp

@@ -1,115 +1,36 @@
 #include <random>
 
 #include "headers/advanced-scene-switcher.hpp"
+#include "headers/utility.hpp"
 
-void SceneSwitcher::on_randomScenesList_currentRowChanged(int idx)
+bool RandomSwitch::pause = false;
+static QMetaObject::Connection addPulse;
+
+void AdvSceneSwitcher::on_randomAdd_clicked()
 {
-	if (loading)
-		return;
-	if (idx == -1)
-		return;
-
-	QListWidgetItem *item = ui->randomScenesList->item(idx);
-
-	QString randomSceneStr = item->data(Qt::UserRole).toString();
-
 	std::lock_guard<std::mutex> lock(switcher->m);
-	for (auto &s : switcher->randomSwitches) {
-		if (randomSceneStr.compare(s.randomSwitchStr.c_str()) == 0) {
-			QString sceneName = GetWeakSourceName(s.scene).c_str();
-			QString transitionName =
-				GetWeakSourceName(s.transition).c_str();
-			ui->randomScenes->setCurrentText(sceneName);
-			ui->randomSpinBox->setValue(s.delay);
-			ui->randomTransitions->setCurrentText(transitionName);
-			break;
-		}
-	}
+	switcher->randomSwitches.emplace_back();
+
+	listAddClicked(ui->randomSwitches,
+		       new RandomSwitchWidget(this,
+					      &switcher->randomSwitches.back()),
+		       ui->randomAdd, &addPulse);
+
+	ui->randomHelp->setVisible(false);
 }
 
-int SceneSwitcher::randomFindByData(const QString &randomStr)
+void AdvSceneSwitcher::on_randomRemove_clicked()
 {
-	int count = ui->randomScenesList->count();
-
-	for (int i = 0; i < count; i++) {
-		QListWidgetItem *item = ui->randomScenesList->item(i);
-		QString str = item->data(Qt::UserRole).toString();
-
-		if (str == randomStr)
-			return i;
-	}
-
-	return -1;
-}
-
-void SceneSwitcher::on_randomAdd_clicked()
-{
-	QString sceneName = ui->randomScenes->currentText();
-	QString transitionName = ui->randomTransitions->currentText();
-	double delay = ui->randomSpinBox->value();
-
-	if (sceneName.isEmpty())
+	QListWidgetItem *item = ui->randomSwitches->currentItem();
+	if (!item) {
 		return;
-
-	OBSWeakSource source = GetWeakSourceByQString(sceneName);
-	OBSWeakSource transition = GetWeakTransitionByQString(transitionName);
-
-	QString text = MakeRandomSwitchName(sceneName, transitionName, delay);
-	QVariant v = QVariant::fromValue(text);
-
-	int idx = randomFindByData(text);
-
-	if (idx == -1) {
-		std::lock_guard<std::mutex> lock(switcher->m);
-		switcher->randomSwitches.emplace_back(
-			source, transition, delay, text.toUtf8().constData());
-
-		QListWidgetItem *item =
-			new QListWidgetItem(text, ui->randomScenesList);
-		item->setData(Qt::UserRole, v);
-	} else {
-		QListWidgetItem *item = ui->randomScenesList->item(idx);
-		item->setText(text);
-
-		{
-			std::lock_guard<std::mutex> lock(switcher->m);
-			for (auto &s : switcher->randomSwitches) {
-				if (s.scene == source) {
-					s.delay = delay;
-					s.transition = transition;
-					s.randomSwitchStr =
-						text.toUtf8().constData();
-					;
-					break;
-				}
-			}
-		}
-
-		ui->randomScenesList->sortItems();
 	}
-}
-
-void SceneSwitcher::on_randomRemove_clicked()
-{
-	QListWidgetItem *item = ui->randomScenesList->currentItem();
-	if (!item)
-		return;
-
-	std::string text =
-		item->data(Qt::UserRole).toString().toUtf8().constData();
 
 	{
 		std::lock_guard<std::mutex> lock(switcher->m);
+		int idx = ui->randomSwitches->currentRow();
 		auto &switches = switcher->randomSwitches;
-
-		for (auto it = switches.begin(); it != switches.end(); ++it) {
-			auto &s = *it;
-
-			if (s.randomSwitchStr == text) {
-				switches.erase(it);
-				break;
-			}
-		}
+		switches.erase(switches.begin() + idx);
 	}
 
 	delete item;
@@ -118,24 +39,32 @@ void SceneSwitcher::on_randomRemove_clicked()
 void SwitcherData::checkRandom(bool &match, OBSWeakSource &scene,
 			       OBSWeakSource &transition, int &delay)
 {
-	if (randomSwitches.size() == 0)
+	if (randomSwitches.size() == 0 || RandomSwitch::pause) {
 		return;
+	}
 
-	std::vector<RandomSwitch> rs(randomSwitches);
+	std::deque<RandomSwitch> rs(randomSwitches);
 	std::random_device rng;
 	std::mt19937 urng(rng());
 	std::shuffle(rs.begin(), rs.end(), urng);
 	for (RandomSwitch &r : rs) {
-		if (r.scene == lastRandomScene)
+		if (!r.initialized()) {
 			continue;
-		scene = r.scene;
+		}
+
+		if (r.scene == lastRandomScene && randomSwitches.size() != 1) {
+			continue;
+		}
+
+		scene = r.getScene();
 		transition = r.transition;
 		delay = (int)r.delay * 1000;
 		match = true;
 		lastRandomScene = r.scene;
 
-		if (verbose)
+		if (verbose) {
 			r.logMatch();
+		}
 		break;
 	}
 }
@@ -146,22 +75,8 @@ void SwitcherData::saveRandomSwitches(obs_data_t *obj)
 	for (RandomSwitch &s : switcher->randomSwitches) {
 		obs_data_t *array_obj = obs_data_create();
 
-		obs_source_t *source = obs_weak_source_get_source(s.scene);
-		obs_source_t *transition =
-			obs_weak_source_get_source(s.transition);
-
-		if (source && transition) {
-			const char *sceneName = obs_source_get_name(source);
-			const char *transitionName =
-				obs_source_get_name(transition);
-			obs_data_set_string(array_obj, "scene", sceneName);
-			obs_data_set_string(array_obj, "transition",
-					    transitionName);
-			obs_data_set_double(array_obj, "delay", s.delay);
-			obs_data_array_push_back(randomArray, array_obj);
-			obs_source_release(source);
-			obs_source_release(transition);
-		}
+		s.save(array_obj);
+		obs_data_array_push_back(randomArray, array_obj);
 
 		obs_data_release(array_obj);
 	}
@@ -180,48 +95,107 @@ void SwitcherData::loadRandomSwitches(obs_data_t *obj)
 	for (size_t i = 0; i < count; i++) {
 		obs_data_t *array_obj = obs_data_array_item(randomArray, i);
 
-		const char *scene = obs_data_get_string(array_obj, "scene");
-		const char *transition =
-			obs_data_get_string(array_obj, "transition");
-		double delay = obs_data_get_double(array_obj, "delay");
-
-		std::string randomSwitchStr =
-			MakeRandomSwitchName(scene, transition, delay)
-				.toUtf8()
-				.constData();
-
-		switcher->randomSwitches.emplace_back(
-			GetWeakSourceByName(scene),
-			GetWeakTransitionByName(transition), delay,
-			randomSwitchStr);
+		switcher->randomSwitches.emplace_back();
+		randomSwitches.back().load(array_obj);
 
 		obs_data_release(array_obj);
 	}
 	obs_data_array_release(randomArray);
 }
 
-void SceneSwitcher::setupRandomTab()
+void AdvSceneSwitcher::setupRandomTab()
 {
-	populateSceneSelection(ui->randomScenes, false);
-	populateTransitionSelection(ui->randomTransitions);
-
 	for (auto &s : switcher->randomSwitches) {
-		std::string sceneName = GetWeakSourceName(s.scene);
-		std::string transitionName = GetWeakSourceName(s.transition);
-		QString text = MakeRandomSwitchName(
-			sceneName.c_str(), transitionName.c_str(), s.delay);
+		QListWidgetItem *item;
+		item = new QListWidgetItem(ui->randomSwitches);
+		ui->randomSwitches->addItem(item);
+		RandomSwitchWidget *sw = new RandomSwitchWidget(this, &s);
+		item->setSizeHint(sw->minimumSizeHint());
+		ui->randomSwitches->setItemWidget(item, sw);
+	}
 
-		QListWidgetItem *item =
-			new QListWidgetItem(text, ui->randomScenesList);
-		item->setData(Qt::UserRole, text);
+	if (switcher->randomSwitches.size() == 0) {
+		addPulse = PulseWidget(ui->randomAdd, QColor(Qt::green));
+		ui->randomHelp->setVisible(true);
+	} else {
+		ui->randomHelp->setVisible(false);
+	}
+
+	if (switcher->switchIfNotMatching != RANDOM_SWITCH) {
+		PulseWidget(ui->randomDisabledWarning, QColor(Qt::red),
+			    QColor(0, 0, 0, 0), "QLabel ");
+	} else {
+		ui->randomDisabledWarning->setVisible(false);
 	}
 }
 
-static inline QString MakeRandomSwitchName(const QString &scene,
-					   const QString &transition,
-					   double &delay)
+void RandomSwitch::save(obs_data_t *obj)
 {
-	return QStringLiteral("[") + scene + QStringLiteral(", ") + transition +
-	       QStringLiteral("]: ") + QString::number(delay) +
-	       QStringLiteral(" seconds");
+	SceneSwitcherEntry::save(obj, "targetType", "scene");
+	obs_data_set_double(obj, "delay", delay);
+}
+
+void RandomSwitch::load(obs_data_t *obj)
+{
+	SceneSwitcherEntry::load(obj, "targetType", "scene");
+	delay = obs_data_get_double(obj, "delay");
+}
+
+RandomSwitchWidget::RandomSwitchWidget(QWidget *parent, RandomSwitch *s)
+	: SwitchWidget(parent, s, false, false)
+{
+	delay = new QDoubleSpinBox();
+
+	QWidget::connect(delay, SIGNAL(valueChanged(double)), this,
+			 SLOT(DelayChanged(double)));
+
+	delay->setSuffix("s");
+	delay->setMaximum(999999999.9);
+
+	if (s) {
+		delay->setValue(s->delay);
+	}
+
+	QHBoxLayout *mainLayout = new QHBoxLayout;
+	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
+		{"{{scenes}}", scenes},
+		{"{{transitions}}", transitions},
+		{"{{delay}}", delay}};
+	placeWidgets(obs_module_text("AdvSceneSwitcher.randomTab.entry"),
+		     mainLayout, widgetPlaceholders);
+	setLayout(mainLayout);
+
+	switchData = s;
+
+	loading = false;
+}
+
+RandomSwitch *RandomSwitchWidget::getSwitchData()
+{
+	return switchData;
+}
+
+void RandomSwitchWidget::setSwitchData(RandomSwitch *s)
+{
+	switchData = s;
+}
+
+void RandomSwitchWidget::swapSwitchData(RandomSwitchWidget *s1,
+					RandomSwitchWidget *s2)
+{
+	SwitchWidget::swapSwitchData(s1, s2);
+
+	RandomSwitch *t = s1->getSwitchData();
+	s1->setSwitchData(s2->getSwitchData());
+	s2->setSwitchData(t);
+}
+
+void RandomSwitchWidget::DelayChanged(double d)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->delay = d;
 }

src/switch-screen-region.cpp

@@ -1,193 +1,199 @@
 #include <QTimer>
 
 #include "headers/advanced-scene-switcher.hpp"
+#include "headers/utility.hpp"
 
-void SwitcherData::checkScreenRegionSwitch(bool &match, OBSWeakSource &scene,
-					   OBSWeakSource &transition)
+bool ScreenRegionSwitch::pause = false;
+static QMetaObject::Connection addPulse;
+
+void AdvSceneSwitcher::clearFrames(QListWidget *list)
 {
-	std::pair<int, int> cursorPos = getCursorPos();
-	int minRegionSize = 99999;
-
-	for (auto &s : screenRegionSwitches) {
-		if (cursorPos.first >= s.minX && cursorPos.second >= s.minY &&
-		    cursorPos.first <= s.maxX && cursorPos.second <= s.maxY) {
-			int regionSize = (s.maxX - s.minX) + (s.maxY - s.minY);
-			if (regionSize < minRegionSize) {
-				match = true;
-				scene = s.scene;
-				transition = s.transition;
-				minRegionSize = regionSize;
-
-				if (verbose)
-					s.logMatch();
-				break;
-			}
-		}
+	for (int i = 0; i < list->count(); ++i) {
+		ScreenRegionWidget *sw =
+			(ScreenRegionWidget *)list->itemWidget(list->item(i));
+		sw->hideFrame();
 	}
 }
 
-void SceneSwitcher::updateScreenRegionCursorPos()
+void showCurrentFrame(QListWidget *list)
 {
-	std::pair<int, int> position = getCursorPos();
-	ui->cursorXPosition->setText(QString::number(position.first));
-	ui->cursorYPosition->setText(QString::number(position.second));
+	QListWidgetItem *item = list->currentItem();
+
+	if (!item) {
+		return;
+	}
+
+	ScreenRegionWidget *sw = (ScreenRegionWidget *)list->itemWidget(item);
+	sw->showFrame();
 }
 
-void SceneSwitcher::on_screenRegionAdd_clicked()
+void AdvSceneSwitcher::SetShowFrames()
 {
-	QString sceneName = ui->screenRegionScenes->currentText();
-	QString transitionName = ui->screenRegionsTransitions->currentText();
+	ui->showFrame->setText(obs_module_text(
+		"AdvSceneSwitcher.screenRegionTab.showGuideFrames"));
+}
 
-	if (sceneName.isEmpty())
-		return;
+void AdvSceneSwitcher::SetHideFrames()
+{
+	ui->showFrame->setText(obs_module_text(
+		"AdvSceneSwitcher.screenRegionTab.hideGuideFrames"));
+}
 
-	int minX = ui->screenRegionMinX->value();
-	int minY = ui->screenRegionMinY->value();
-	int maxX = ui->screenRegionMaxX->value();
-	int maxY = ui->screenRegionMaxY->value();
+void AdvSceneSwitcher::on_showFrame_clicked()
+{
+	switcher->showFrame = !switcher->showFrame;
 
-	std::string regionStr =
-		std::to_string(minX) + ", " + std::to_string(minY) + " x " +
-		std::to_string(maxX) + ", " + std::to_string(maxY);
-	QString region = QString::fromStdString(regionStr);
-
-	OBSWeakSource source = GetWeakSourceByQString(sceneName);
-	OBSWeakSource transition = GetWeakTransitionByQString(transitionName);
-	QVariant v = QVariant::fromValue(region);
-
-	QString text = MakeScreenRegionSwitchName(sceneName, transitionName,
-						  minX, minY, maxX, maxY);
-
-	int idx = ScreenRegionFindByData(region);
-
-	if (idx == -1) {
-		QListWidgetItem *item =
-			new QListWidgetItem(text, ui->screenRegions);
-		item->setData(Qt::UserRole, v);
-
-		std::lock_guard<std::mutex> lock(switcher->m);
-		switcher->screenRegionSwitches.emplace_back(
-			source, transition, minX, minY, maxX, maxY, regionStr);
+	if (switcher->showFrame) {
+		SetHideFrames();
+		showCurrentFrame(ui->screenRegionSwitches);
 	} else {
-		QListWidgetItem *item = ui->screenRegions->item(idx);
-		item->setText(text);
-
-		std::string curRegion = region.toUtf8().constData();
-
-		{
-			std::lock_guard<std::mutex> lock(switcher->m);
-			for (auto &s : switcher->screenRegionSwitches) {
-				if (s.regionStr == curRegion) {
-					s.scene = source;
-					s.transition = transition;
-					break;
-				}
-			}
-		}
+		SetShowFrames();
+		clearFrames(ui->screenRegionSwitches);
 	}
 }
 
-void SceneSwitcher::on_screenRegionRemove_clicked()
+void AdvSceneSwitcher::on_screenRegionSwitches_currentRowChanged(int idx)
 {
-	QListWidgetItem *item = ui->screenRegions->currentItem();
-	if (!item)
+	if (loading || idx == -1) {
 		return;
+	}
 
-	std::string region =
-		item->data(Qt::UserRole).toString().toUtf8().constData();
+	if (switcher->showFrame) {
+		clearFrames(ui->screenRegionSwitches);
+		showCurrentFrame(ui->screenRegionSwitches);
+	}
+}
+
+void AdvSceneSwitcher::on_screenRegionAdd_clicked()
+{
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switcher->screenRegionSwitches.emplace_back();
+
+	listAddClicked(ui->screenRegionSwitches,
+		       new ScreenRegionWidget(
+			       this, &switcher->screenRegionSwitches.back()),
+		       ui->screenRegionAdd, &addPulse);
+
+	ui->regionHelp->setVisible(false);
+}
+
+void AdvSceneSwitcher::on_screenRegionRemove_clicked()
+{
+	QListWidgetItem *item = ui->screenRegionSwitches->currentItem();
+	if (!item) {
+		return;
+	}
 
 	{
 		std::lock_guard<std::mutex> lock(switcher->m);
+		int idx = ui->screenRegionSwitches->currentRow();
 		auto &switches = switcher->screenRegionSwitches;
-
-		for (auto it = switches.begin(); it != switches.end(); ++it) {
-			auto &s = *it;
-
-			if (s.regionStr == region) {
-				switches.erase(it);
-				break;
-			}
-		}
+		switches.erase(switches.begin() + idx);
 	}
 
 	delete item;
 }
 
-void SceneSwitcher::on_screenRegions_currentRowChanged(int idx)
+void AdvSceneSwitcher::on_screenRegionUp_clicked()
 {
-	if (loading)
-		return;
-	if (idx == -1)
+	int index = ui->screenRegionSwitches->currentRow();
+	if (!listMoveUp(ui->screenRegionSwitches)) {
 		return;
+	}
 
-	QListWidgetItem *item = ui->screenRegions->item(idx);
-
-	QString region = item->data(Qt::UserRole).toString();
+	ScreenRegionWidget *s1 =
+		(ScreenRegionWidget *)ui->screenRegionSwitches->itemWidget(
+			ui->screenRegionSwitches->item(index));
+	ScreenRegionWidget *s2 =
+		(ScreenRegionWidget *)ui->screenRegionSwitches->itemWidget(
+			ui->screenRegionSwitches->item(index - 1));
+	ScreenRegionWidget::swapSwitchData(s1, s2);
 
 	std::lock_guard<std::mutex> lock(switcher->m);
-	for (auto &s : switcher->screenRegionSwitches) {
-		if (region.compare(s.regionStr.c_str()) == 0) {
-			std::string name = GetWeakSourceName(s.scene);
-			std::string transitionName =
-				GetWeakSourceName(s.transition);
-			ui->screenRegionScenes->setCurrentText(name.c_str());
-			ui->screenRegionsTransitions->setCurrentText(
-				transitionName.c_str());
-			ui->screenRegionMinX->setValue(s.minX);
-			ui->screenRegionMinY->setValue(s.minY);
-			ui->screenRegionMaxX->setValue(s.maxX);
-			ui->screenRegionMaxY->setValue(s.maxY);
-			break;
+
+	std::swap(switcher->screenRegionSwitches[index],
+		  switcher->screenRegionSwitches[index - 1]);
+}
+
+void AdvSceneSwitcher::on_screenRegionDown_clicked()
+{
+	int index = ui->screenRegionSwitches->currentRow();
+
+	if (!listMoveDown(ui->screenRegionSwitches)) {
+		return;
+	}
+
+	ScreenRegionWidget *s1 =
+		(ScreenRegionWidget *)ui->screenRegionSwitches->itemWidget(
+			ui->screenRegionSwitches->item(index));
+	ScreenRegionWidget *s2 =
+		(ScreenRegionWidget *)ui->screenRegionSwitches->itemWidget(
+			ui->screenRegionSwitches->item(index + 1));
+	ScreenRegionWidget::swapSwitchData(s1, s2);
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+
+	std::swap(switcher->screenRegionSwitches[index],
+		  switcher->screenRegionSwitches[index + 1]);
+}
+
+bool shouldIgnoreSceneSwitch(ScreenRegionSwitch &matchingRegion)
+{
+	if (!matchingRegion.excludeScene) {
+		return false;
+	}
+
+	obs_source_t *currentScene = obs_frontend_get_current_scene();
+	OBSWeakSource ws = obs_source_get_weak_source(currentScene);
+	obs_weak_source_release(ws);
+	obs_source_release(currentScene);
+
+	return matchingRegion.excludeScene == ws;
+}
+
+void SwitcherData::checkScreenRegionSwitch(bool &match, OBSWeakSource &scene,
+					   OBSWeakSource &transition)
+{
+	if (ScreenRegionSwitch::pause) {
+		return;
+	}
+
+	std::pair<int, int> cursorPos = getCursorPos();
+	int minRegionSize = 99999;
+
+	for (auto &s : screenRegionSwitches) {
+		if (!s.initialized()) {
+			continue;
+		}
+
+		if (cursorPos.first >= s.minX && cursorPos.second >= s.minY &&
+		    cursorPos.first <= s.maxX && cursorPos.second <= s.maxY) {
+			int regionSize = (s.maxX - s.minX) + (s.maxY - s.minY);
+			if (regionSize < minRegionSize) {
+				if (shouldIgnoreSceneSwitch(s)) {
+					// We technically have a match.
+					// But just ignore it.
+					return;
+				}
+				match = true;
+				scene = s.getScene();
+				transition = s.transition;
+				minRegionSize = regionSize;
+
+				if (verbose) {
+					s.logMatch();
+				}
+				break;
+			}
 		}
 	}
 }
 
-int SceneSwitcher::ScreenRegionFindByData(const QString &region)
+void AdvSceneSwitcher::updateScreenRegionCursorPos()
 {
-	int count = ui->screenRegions->count();
-	int idx = -1;
-
-	for (int i = 0; i < count; i++) {
-		QListWidgetItem *item = ui->screenRegions->item(i);
-		QString itemRegion = item->data(Qt::UserRole).toString();
-
-		if (itemRegion == region) {
-			idx = i;
-			break;
-		}
-	}
-
-	return idx;
-}
-
-void SceneSwitcher::on_screenRegionUp_clicked()
-{
-	int index = ui->screenRegions->currentRow();
-	if (index != -1 && index != 0) {
-		ui->screenRegions->insertItem(
-			index - 1, ui->screenRegions->takeItem(index));
-		ui->screenRegions->setCurrentRow(index - 1);
-
-		std::lock_guard<std::mutex> lock(switcher->m);
-
-		iter_swap(switcher->screenRegionSwitches.begin() + index,
-			  switcher->screenRegionSwitches.begin() + index - 1);
-	}
-}
-
-void SceneSwitcher::on_screenRegionDown_clicked()
-{
-	int index = ui->screenRegions->currentRow();
-	if (index != -1 && index != ui->screenRegions->count() - 1) {
-		ui->screenRegions->insertItem(
-			index + 1, ui->screenRegions->takeItem(index));
-		ui->screenRegions->setCurrentRow(index + 1);
-
-		std::lock_guard<std::mutex> lock(switcher->m);
-
-		iter_swap(switcher->screenRegionSwitches.begin() + index,
-			  switcher->screenRegionSwitches.begin() + index + 1);
-	}
+	std::pair<int, int> position = getCursorPos();
+	ui->cursorXPosition->setText(QString::number(position.first));
+	ui->cursorYPosition->setText(QString::number(position.second));
 }
 
 void SwitcherData::saveScreenRegionSwitches(obs_data_t *obj)
@@ -196,25 +202,8 @@ void SwitcherData::saveScreenRegionSwitches(obs_data_t *obj)
 	for (ScreenRegionSwitch &s : switcher->screenRegionSwitches) {
 		obs_data_t *array_obj = obs_data_create();
 
-		obs_source_t *source = obs_weak_source_get_source(s.scene);
-		obs_source_t *transition =
-			obs_weak_source_get_source(s.transition);
-		if (source && transition) {
-			const char *sceneName = obs_source_get_name(source);
-			const char *transitionName =
-				obs_source_get_name(transition);
-			obs_data_set_string(array_obj, "screenRegionScene",
-					    sceneName);
-			obs_data_set_string(array_obj, "transition",
-					    transitionName);
-			obs_data_set_int(array_obj, "minX", s.minX);
-			obs_data_set_int(array_obj, "minY", s.minY);
-			obs_data_set_int(array_obj, "maxX", s.maxX);
-			obs_data_set_int(array_obj, "maxY", s.maxY);
-			obs_data_array_push_back(screenRegionArray, array_obj);
-			obs_source_release(source);
-			obs_source_release(transition);
-		}
+		s.save(array_obj);
+		obs_data_array_push_back(screenRegionArray, array_obj);
 
 		obs_data_release(array_obj);
 	}
@@ -234,46 +223,30 @@ void SwitcherData::loadScreenRegionSwitches(obs_data_t *obj)
 		obs_data_t *array_obj =
 			obs_data_array_item(screenRegionArray, i);
 
-		const char *scene =
-			obs_data_get_string(array_obj, "screenRegionScene");
-		const char *transition =
-			obs_data_get_string(array_obj, "transition");
-		int minX = obs_data_get_int(array_obj, "minX");
-		int minY = obs_data_get_int(array_obj, "minY");
-		int maxX = obs_data_get_int(array_obj, "maxX");
-		int maxY = obs_data_get_int(array_obj, "maxY");
-
-		std::string regionStr =
-			MakeScreenRegionSwitchName(scene, transition, minX,
-						   minY, maxX, maxY)
-				.toUtf8()
-				.constData();
-
-		switcher->screenRegionSwitches.emplace_back(
-			GetWeakSourceByName(scene),
-			GetWeakTransitionByName(transition), minX, minY, maxX,
-			maxY, regionStr);
+		switcher->screenRegionSwitches.emplace_back();
+		screenRegionSwitches.back().load(array_obj);
 
 		obs_data_release(array_obj);
 	}
 	obs_data_array_release(screenRegionArray);
 }
 
-void SceneSwitcher::setupRegionTab()
+void AdvSceneSwitcher::setupRegionTab()
 {
-	populateSceneSelection(ui->screenRegionScenes, false);
-	populateTransitionSelection(ui->screenRegionsTransitions);
-
 	for (auto &s : switcher->screenRegionSwitches) {
-		std::string sceneName = GetWeakSourceName(s.scene);
-		std::string transitionName = GetWeakSourceName(s.transition);
-		QString text = MakeScreenRegionSwitchName(
-			sceneName.c_str(), transitionName.c_str(), s.minX,
-			s.minY, s.maxX, s.maxY);
+		QListWidgetItem *item;
+		item = new QListWidgetItem(ui->screenRegionSwitches);
+		ui->screenRegionSwitches->addItem(item);
+		ScreenRegionWidget *sw = new ScreenRegionWidget(this, &s);
+		item->setSizeHint(sw->minimumSizeHint());
+		ui->screenRegionSwitches->setItemWidget(item, sw);
+	}
 
-		QListWidgetItem *item =
-			new QListWidgetItem(text, ui->screenRegions);
-		item->setData(Qt::UserRole, s.regionStr.c_str());
+	if (switcher->screenRegionSwitches.size() == 0) {
+		addPulse = PulseWidget(ui->screenRegionAdd, QColor(Qt::green));
+		ui->regionHelp->setVisible(true);
+	} else {
+		ui->regionHelp->setVisible(false);
 	}
 
 	// screen region cursor position
@@ -283,14 +256,233 @@ void SceneSwitcher::setupRegionTab()
 	screenRegionTimer->start(1000);
 }
 
-static inline QString MakeScreenRegionSwitchName(const QString &scene,
-						 const QString &transition,
-						 int minX, int minY, int maxX,
-						 int maxY)
+void ScreenRegionSwitch::save(obs_data_t *obj)
 {
-	return QStringLiteral("[") + scene + QStringLiteral(", ") + transition +
-	       QStringLiteral("]: ") + QString::number(minX) +
-	       QStringLiteral(", ") + QString::number(minY) +
-	       QStringLiteral(" x ") + QString::number(maxX) +
-	       QStringLiteral(", ") + QString::number(maxY);
+	SceneSwitcherEntry::save(obj);
+
+	obs_data_set_string(obj, "excludeScene",
+			    GetWeakSourceName(excludeScene).c_str());
+
+	obs_data_set_int(obj, "minX", minX);
+	obs_data_set_int(obj, "minY", minY);
+	obs_data_set_int(obj, "maxX", maxX);
+	obs_data_set_int(obj, "maxY", maxY);
+}
+
+// To be removed in future version
+bool loadOldRegion(obs_data_t *obj, ScreenRegionSwitch *s)
+{
+	if (!s) {
+		return false;
+	}
+
+	const char *scene = obs_data_get_string(obj, "screenRegionScene");
+
+	if (strcmp(scene, "") == 0) {
+		return false;
+	}
+
+	s->scene = GetWeakSourceByName(scene);
+
+	const char *transition = obs_data_get_string(obj, "transition");
+	s->transition = GetWeakTransitionByName(transition);
+
+	s->minX = obs_data_get_int(obj, "minX");
+	s->minY = obs_data_get_int(obj, "minY");
+	s->maxX = obs_data_get_int(obj, "maxX");
+	s->maxY = obs_data_get_int(obj, "maxY");
+
+	s->usePreviousScene = strcmp(scene, previous_scene_name) == 0;
+
+	return true;
+}
+
+void ScreenRegionSwitch::load(obs_data_t *obj)
+{
+	if (loadOldRegion(obj, this)) {
+		return;
+	}
+
+	SceneSwitcherEntry::load(obj);
+
+	const char *excludeSceneName = obs_data_get_string(obj, "excludeScene");
+	excludeScene = GetWeakSourceByName(excludeSceneName);
+
+	minX = obs_data_get_int(obj, "minX");
+	minY = obs_data_get_int(obj, "minY");
+	maxX = obs_data_get_int(obj, "maxX");
+	maxY = obs_data_get_int(obj, "maxY");
+}
+
+ScreenRegionWidget::ScreenRegionWidget(QWidget *parent, ScreenRegionSwitch *s)
+	: SwitchWidget(parent, s, true, true)
+{
+	excludeScenes = new QComboBox();
+	minX = new QSpinBox();
+	minY = new QSpinBox();
+	maxX = new QSpinBox();
+	maxY = new QSpinBox();
+
+	minX->setPrefix("Min X: ");
+	minY->setPrefix("Min Y: ");
+	maxX->setPrefix("Max X: ");
+	maxY->setPrefix("Max Y: ");
+
+	minX->setMinimum(-1000000);
+	minY->setMinimum(-1000000);
+	maxX->setMinimum(-1000000);
+	maxY->setMinimum(-1000000);
+
+	minX->setMaximum(1000000);
+	minY->setMaximum(1000000);
+	maxX->setMaximum(1000000);
+	maxY->setMaximum(1000000);
+
+	QWidget::connect(excludeScenes,
+			 SIGNAL(currentTextChanged(const QString &)), this,
+			 SLOT(ExcludeSceneChanged(const QString &)));
+	QWidget::connect(minX, SIGNAL(valueChanged(int)), this,
+			 SLOT(MinXChanged(int)));
+	QWidget::connect(minY, SIGNAL(valueChanged(int)), this,
+			 SLOT(MinYChanged(int)));
+	QWidget::connect(maxX, SIGNAL(valueChanged(int)), this,
+			 SLOT(MaxXChanged(int)));
+	QWidget::connect(maxY, SIGNAL(valueChanged(int)), this,
+			 SLOT(MaxYChanged(int)));
+
+	AdvSceneSwitcher::populateSceneSelection(
+		excludeScenes, false, false, true,
+		obs_module_text(
+			"AdvSceneSwitcher.screenRegionTab.excludeScenes.None"));
+
+	if (s) {
+		excludeScenes->setCurrentText(
+			GetWeakSourceName(s->excludeScene).c_str());
+		minX->setValue(s->minX);
+		minY->setValue(s->minY);
+		maxX->setValue(s->maxX);
+		maxY->setValue(s->maxY);
+	}
+
+	QHBoxLayout *mainLayout = new QHBoxLayout;
+	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
+		{"{{minX}}", minX},
+		{"{{minY}}", minY},
+		{"{{maxX}}", maxX},
+		{"{{maxY}}", maxY},
+		{"{{scenes}}", scenes},
+		{"{{transitions}}", transitions},
+		{"{{excludeScenes}}", excludeScenes}};
+	placeWidgets(obs_module_text("AdvSceneSwitcher.screenRegionTab.entry"),
+		     mainLayout, widgetPlaceholders);
+	setLayout(mainLayout);
+
+	switchData = s;
+
+	loading = false;
+}
+
+ScreenRegionSwitch *ScreenRegionWidget::getSwitchData()
+{
+	return switchData;
+}
+
+void ScreenRegionWidget::setSwitchData(ScreenRegionSwitch *s)
+{
+	switchData = s;
+}
+
+void ScreenRegionWidget::swapSwitchData(ScreenRegionWidget *s1,
+					ScreenRegionWidget *s2)
+{
+	SwitchWidget::swapSwitchData(s1, s2);
+
+	ScreenRegionSwitch *t = s1->getSwitchData();
+	s1->setSwitchData(s2->getSwitchData());
+	s2->setSwitchData(t);
+}
+
+void ScreenRegionWidget::showFrame()
+{
+	drawFrame();
+	helperFrame.show();
+}
+
+void ScreenRegionWidget::hideFrame()
+{
+	helperFrame.hide();
+}
+
+void ScreenRegionWidget::ExcludeSceneChanged(const QString &text)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->excludeScene = GetWeakSourceByQString(text);
+}
+
+void ScreenRegionWidget::MinXChanged(int pos)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->minX = pos;
+
+	drawFrame();
+}
+
+void ScreenRegionWidget::MinYChanged(int pos)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->minY = pos;
+
+	drawFrame();
+}
+
+void ScreenRegionWidget::MaxXChanged(int pos)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->maxX = pos;
+
+	drawFrame();
+}
+
+void ScreenRegionWidget::MaxYChanged(int pos)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->maxY = pos;
+
+	drawFrame();
+}
+
+void ScreenRegionWidget::drawFrame()
+{
+	helperFrame.setFrameStyle(QFrame::Box | QFrame::Plain);
+	helperFrame.setWindowFlags(Qt::FramelessWindowHint | Qt::Tool |
+				   Qt::WindowTransparentForInput |
+				   Qt::WindowDoesNotAcceptFocus |
+				   Qt::WindowStaysOnTopHint);
+	helperFrame.setAttribute(Qt::WA_TranslucentBackground, true);
+
+	if (switchData) {
+		helperFrame.setGeometry(switchData->minX, switchData->minY,
+					switchData->maxX - switchData->minX,
+					switchData->maxY - switchData->minY);
+	}
 }

src/switch-sequence.cpp

@@ -1,143 +1,111 @@
 #include <QFileDialog>
 #include <QTextStream>
-#include <QMessageBox>
 
 #include "headers/advanced-scene-switcher.hpp"
+#include "headers/utility.hpp"
 
-constexpr auto seconds_index = 0;
-constexpr auto minutes_index = 1;
-constexpr auto hours_index = 2;
+bool SceneSequenceSwitch::pause = false;
+static QMetaObject::Connection addPulse;
 
-void SceneSwitcher::on_sceneSequenceDelayUnits_currentIndexChanged(int index)
+void AdvSceneSwitcher::on_sceneSequenceAdd_clicked()
 {
-	if (loading)
-		return;
-
 	std::lock_guard<std::mutex> lock(switcher->m);
+	switcher->sceneSequenceSwitches.emplace_back();
 
-	double val = ui->sceneSequenceSpinBox->value();
+	listAddClicked(ui->sceneSequenceSwitches,
+		       new SequenceWidget(
+			       this, &switcher->sceneSequenceSwitches.back()),
+		       ui->sceneSequenceAdd, &addPulse);
 
-	switch (switcher->sceneSequenceMultiplier) {
-	case 1:
-		val /= pow(60, index);
-		break;
-	case 60:
-		val /= pow(60, index - 1);
-		break;
-	case 3600:
-		val /= pow(60, index - 2);
-		break;
-	}
-
-	ui->sceneSequenceSpinBox->setValue(val);
-
-	switch (index) {
-	case seconds_index:
-		switcher->sceneSequenceMultiplier = 1;
-		break;
-	case minutes_index:
-		switcher->sceneSequenceMultiplier = 60;
-		break;
-	case hours_index:
-		switcher->sceneSequenceMultiplier = 3600;
-		break;
-	}
+	ui->sequenceHelp->setVisible(false);
 }
 
-void SceneSwitcher::on_sceneSequenceAdd_clicked()
+void AdvSceneSwitcher::on_sceneSequenceRemove_clicked()
 {
-	QString scene1Name = ui->sceneSequenceScenes1->currentText();
-	QString scene2Name = ui->sceneSequenceScenes2->currentText();
-	QString transitionName = ui->sceneSequenceTransitions->currentText();
-
-	if (scene1Name.isEmpty() || scene2Name.isEmpty())
+	QListWidgetItem *item = ui->sceneSequenceSwitches->currentItem();
+	if (!item) {
 		return;
-
-	double delay = ui->sceneSequenceSpinBox->value() *
-		       switcher->sceneSequenceMultiplier;
-
-	if (scene1Name == scene2Name)
-		return;
-
-	OBSWeakSource source1 = GetWeakSourceByQString(scene1Name);
-	OBSWeakSource source2 = GetWeakSourceByQString(scene2Name);
-	OBSWeakSource transition = GetWeakTransitionByQString(transitionName);
-
-	QString text = MakeSceneSequenceSwitchName(scene1Name, scene2Name,
-						    transitionName, delay);
-	QVariant v = QVariant::fromValue(text);
-
-	int idx = SceneSequenceFindByData(scene1Name);
-
-	if (idx == -1) {
-		QListWidgetItem *item =
-			new QListWidgetItem(text, ui->sceneSequences);
-		item->setData(Qt::UserRole, v);
-
-		std::lock_guard<std::mutex> lock(switcher->m);
-		switcher->sceneSequenceSwitches.emplace_back(
-			source1, source2, transition, delay,
-			(scene2Name == QString(previous_scene_name)),
-			text.toUtf8().constData());
-	} else {
-		QListWidgetItem *item = ui->sceneSequences->item(idx);
-		item->setText(text);
-
-		{
-			std::lock_guard<std::mutex> lock(switcher->m);
-			for (auto &s : switcher->sceneSequenceSwitches) {
-				if (s.startScene == source1) {
-					s.scene = source2;
-					s.delay = delay;
-					s.transition = transition;
-					s.usePreviousScene =
-						(scene2Name ==
-						 QString(previous_scene_name));
-					s.sceneSequenceStr =
-						text.toUtf8().constData();
-					break;
-				}
-			}
-		}
 	}
-}
-
-void SceneSwitcher::on_sceneSequenceRemove_clicked()
-{
-	QListWidgetItem *item = ui->sceneSequences->currentItem();
-	if (!item)
-		return;
-
-	std::string text =
-		item->data(Qt::UserRole).toString().toUtf8().constData();
 
 	{
+		// Might be in waiting state of sequence
+		// causing invalid access after wakeup
+		// thus we need to stop the main thread before delete
+		bool wasRunning = !switcher->stop;
+		switcher->Stop();
+
 		std::lock_guard<std::mutex> lock(switcher->m);
+		int idx = ui->sceneSequenceSwitches->currentRow();
 		auto &switches = switcher->sceneSequenceSwitches;
+		switches.erase(switches.begin() + idx);
 
-		for (auto it = switches.begin(); it != switches.end(); ++it) {
-			auto &s = *it;
-
-			if (s.sceneSequenceStr == text) {
-				switches.erase(it);
-				break;
-			}
+		if (wasRunning) {
+			switcher->Start();
 		}
 	}
 
 	delete item;
 }
 
-void SceneSwitcher::on_sceneSequenceSave_clicked()
+void AdvSceneSwitcher::on_sceneSequenceUp_clicked()
+{
+	int index = ui->sceneSequenceSwitches->currentRow();
+	if (!listMoveUp(ui->sceneSequenceSwitches)) {
+		return;
+	}
+
+	SequenceWidget *s1 =
+		(SequenceWidget *)ui->sceneSequenceSwitches->itemWidget(
+			ui->sceneSequenceSwitches->item(index));
+	SequenceWidget *s2 =
+		(SequenceWidget *)ui->sceneSequenceSwitches->itemWidget(
+			ui->sceneSequenceSwitches->item(index - 1));
+	SequenceWidget::swapSwitchData(s1, s2);
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+
+	std::swap(switcher->sceneSequenceSwitches[index],
+		  switcher->sceneSequenceSwitches[index - 1]);
+}
+
+void AdvSceneSwitcher::on_sceneSequenceDown_clicked()
+{
+	int index = ui->sceneSequenceSwitches->currentRow();
+
+	if (!listMoveDown(ui->sceneSequenceSwitches)) {
+		return;
+	}
+
+	SequenceWidget *s1 =
+		(SequenceWidget *)ui->sceneSequenceSwitches->itemWidget(
+			ui->sceneSequenceSwitches->item(index));
+	SequenceWidget *s2 =
+		(SequenceWidget *)ui->sceneSequenceSwitches->itemWidget(
+			ui->sceneSequenceSwitches->item(index + 1));
+	SequenceWidget::swapSwitchData(s1, s2);
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+
+	std::swap(switcher->sceneSequenceSwitches[index],
+		  switcher->sceneSequenceSwitches[index + 1]);
+}
+
+void AdvSceneSwitcher::on_sceneSequenceSave_clicked()
 {
 	QString directory = QFileDialog::getSaveFileName(
-		this, tr("Save Scene Sequence to file ..."),
-		QDir::currentPath(), tr("Text files (*.txt)"));
-	if (directory.isEmpty())
+		this,
+		tr(obs_module_text(
+			"AdvSceneSwitcher.sceneSequenceTab.saveTitle")),
+		QDir::currentPath(),
+		tr(obs_module_text(
+			"AdvSceneSwitcher.sceneSequenceTab.fileType")));
+	if (directory.isEmpty()) {
 		return;
+	}
 	QFile file(directory);
-	if (!file.open(QIODevice::WriteOnly | QIODevice::Text))
+	if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
 		return;
+	}
 
 	obs_data_t *obj = obs_data_create();
 	switcher->saveSceneSequenceSwitches(obj);
@@ -145,250 +113,127 @@ void SceneSwitcher::on_sceneSequenceSave_clicked()
 	obs_data_release(obj);
 }
 
-// to be removed once support for old file format is dropped
-bool oldSceneRoundTripLoad(QFile *file)
+void AdvSceneSwitcher::on_sceneSequenceLoad_clicked()
 {
-	QTextStream in(file);
-	std::vector<QString> lines;
-
-	std::vector<SceneSequenceSwitch> newSceneRoundTripSwitch;
-
-	while (!in.atEnd()) {
-		QString line = in.readLine();
-		lines.push_back(line);
-		if (lines.size() == 5) {
-			OBSWeakSource scene1 = GetWeakSourceByQString(lines[0]);
-			OBSWeakSource scene2 = GetWeakSourceByQString(lines[1]);
-			OBSWeakSource transition =
-				GetWeakTransitionByQString(lines[4]);
-
-			if (WeakSourceValid(scene1) &&
-			    ((lines[1] == QString(previous_scene_name)) ||
-			     (WeakSourceValid(scene2))) &&
-			    WeakSourceValid(transition)) {
-				newSceneRoundTripSwitch.emplace_back(
-					SceneSequenceSwitch(
-						GetWeakSourceByQString(lines[0]),
-						GetWeakSourceByQString(lines[1]),
-						GetWeakTransitionByQString(
-							lines[4]),
-						lines[2].toDouble() / 1000.,
-						(lines[1] ==
-						 QString(previous_scene_name)),
-						lines[3].toStdString()));
-			}
-			lines.clear();
-		}
+	QString directory = QFileDialog::getOpenFileName(
+		this,
+		tr(obs_module_text(
+			"AdvSceneSwitcher.sceneSequenceTab.loadTitle")),
+		QDir::currentPath(),
+		tr(obs_module_text(
+			"AdvSceneSwitcher.sceneSequenceTab.fileType")));
+	if (directory.isEmpty()) {
+		return;
 	}
 
-	if (lines.size() != 0 || newSceneRoundTripSwitch.size() == 0)
-		return false;
-
-	switcher->sceneSequenceSwitches.clear();
-	switcher->sceneSequenceSwitches = newSceneRoundTripSwitch;
-	return true;
-}
-
-void SceneSwitcher::on_sceneSequenceLoad_clicked()
-{
-	std::lock_guard<std::mutex> lock(switcher->m);
-
-	QString directory = QFileDialog::getOpenFileName(
-		this, tr("Select a file to read Scene Sequence from ..."),
-		QDir::currentPath(), tr("Text files (*.txt)"));
-	if (directory.isEmpty())
-		return;
-
 	QFile file(directory);
-	if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
+	if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
 		return;
+	}
 
 	obs_data_t *obj = obs_data_create_from_json_file(
 		file.fileName().toUtf8().constData());
 
 	if (!obj) {
-		QMessageBox Msgbox;
-		QString txt =
-			"Advanced Scene Switcher failed to import settings!\n";
-		txt += "Falling back to old format.";
-		Msgbox.setText(txt);
-		Msgbox.exec();
-		if (oldSceneRoundTripLoad(&file)) {
-			QString txt =
-				"Advanced Scene Switcher settings imported successfully!\n";
-			txt += "Please resave settings as support for old format will be dropped in next version.";
-			Msgbox.setText(txt);
-			Msgbox.exec();
-			close();
-		} else {
-			Msgbox.setText(
-				"Advanced Scene Switcher failed to import settings!");
-			Msgbox.exec();
-		}
+		DisplayMessage(obs_module_text(
+			"AdvSceneSwitcher.sceneSequenceTab.loadFail"));
 		return;
 	}
+
+	// Might be in waiting state of sequence
+	// causing invalid access after wakeup
+	// thus we need to stop the main thread before delete
+	bool wasRunning = !switcher->stop;
+	switcher->Stop();
+
 	switcher->loadSceneSequenceSwitches(obj);
+
+	if (wasRunning) {
+		switcher->Start();
+	}
+
 	obs_data_release(obj);
 
-	QMessageBox Msgbox;
-	Msgbox.setText(
-		"Advanced Scene Switcher settings imported successfully!");
-	Msgbox.exec();
+	DisplayMessage(obs_module_text(
+		"AdvSceneSwitcher.sceneSequenceTab.loadSuccess"));
 	close();
 }
 
-void SwitcherData::checkSceneSequence(bool &match, OBSWeakSource &scene,
-				       OBSWeakSource &transition,
-				       std::unique_lock<std::mutex> &lock)
+bool matchInterruptible(SwitcherData *switcher, SceneSequenceSwitch &s)
 {
+	bool durationReached = s.matchCount * (switcher->interval / 1000.0) >=
+			       s.delay;
+
+	s.matchCount++;
+
+	if (durationReached) {
+		return true;
+	}
+	return false;
+}
+
+bool matchUninterruptible(SwitcherData *switcher, SceneSequenceSwitch &s,
+			  obs_source_t *currentSource, int &linger)
+{
+	// scene was already active for the previous cycle so remove this time
+	int dur = s.delay * 1000 - switcher->interval;
+	if (dur > 0) {
+		switcher->waitScene = currentSource;
+		linger = dur;
+	}
+
+	return true;
+}
+
+void SwitcherData::checkSceneSequence(bool &match, OBSWeakSource &scene,
+				      OBSWeakSource &transition, int &linger)
+{
+	if (SceneSequenceSwitch::pause) {
+		return;
+	}
+
 	obs_source_t *currentSource = obs_frontend_get_current_scene();
 	obs_weak_source_t *ws = obs_source_get_weak_source(currentSource);
 
 	for (SceneSequenceSwitch &s : sceneSequenceSwitches) {
+		if (!s.initialized()) {
+			continue;
+		}
+
 		if (s.startScene == ws) {
-			int dur = s.delay * 1000 - interval;
-			if (dur > 0) {
-				waitScene = currentSource;
+			if (!match) {
+				if (s.interruptible) {
+					match = matchInterruptible(switcher, s);
+				} else {
+					match = matchUninterruptible(
+						switcher, s, currentSource,
+						linger);
+				}
 
-				if (verbose)
-					s.logSleep(dur);
-
-				cv.wait_for(lock,
-					    std::chrono::milliseconds(dur));
-				waitScene = nullptr;
+				if (match) {
+					scene = s.getScene();
+					transition = s.transition;
+					if (switcher->verbose) {
+						s.logMatch();
+					}
+				}
 			}
-			obs_source_t *currentSource2 =
-				obs_frontend_get_current_scene();
-
-			// only switch if user hasn't changed scene manually
-			if (currentSource == currentSource2) {
-				match = true;
-				scene = (s.usePreviousScene) ? previousScene
-							     : s.scene;
-				transition = s.transition;
-				if (verbose)
-					s.logMatch();
-			}
-			obs_source_release(currentSource2);
-			break;
+		} else {
+			s.matchCount = 0;
 		}
 	}
 	obs_source_release(currentSource);
 	obs_weak_source_release(ws);
 }
 
-void SceneSwitcher::on_sceneSequences_currentRowChanged(int idx)
-{
-	if (loading)
-		return;
-	if (idx == -1)
-		return;
-
-	QListWidgetItem *item = ui->sceneSequences->item(idx);
-
-	QString sceneSequence = item->text();
-
-	std::lock_guard<std::mutex> lock(switcher->m);
-	for (auto &s : switcher->sceneSequenceSwitches) {
-		if (sceneSequence.compare(s.sceneSequenceStr.c_str()) == 0) {
-			std::string scene1 = GetWeakSourceName(s.startScene);
-			std::string scene2 = GetWeakSourceName(s.scene);
-			std::string transitionName =
-				GetWeakSourceName(s.transition);
-			double delay = s.delay /
-				       switcher->sceneSequenceMultiplier;
-			ui->sceneSequenceScenes1->setCurrentText(
-				scene1.c_str());
-			ui->sceneSequenceScenes2->setCurrentText(
-				scene2.c_str());
-			ui->sceneSequenceTransitions->setCurrentText(
-				transitionName.c_str());
-			ui->sceneSequenceSpinBox->setValue(delay);
-			break;
-		}
-	}
-}
-
-int SceneSwitcher::SceneSequenceFindByData(const QString &scene1)
-{
-	QRegExp rx(scene1 + " ->.*");
-	int count = ui->sceneSequences->count();
-	int idx = -1;
-
-	for (int i = 0; i < count; i++) {
-		QListWidgetItem *item = ui->sceneSequences->item(i);
-		QString itemString = item->data(Qt::UserRole).toString();
-
-		if (rx.exactMatch(itemString)) {
-			idx = i;
-			break;
-		}
-	}
-
-	return idx;
-}
-
-void SceneSwitcher::on_sceneSequenceUp_clicked()
-{
-	int index = ui->sceneSequences->currentRow();
-	if (index != -1 && index != 0) {
-		ui->sceneSequences->insertItem(
-			index - 1, ui->sceneSequences->takeItem(index));
-		ui->sceneSequences->setCurrentRow(index - 1);
-
-		std::lock_guard<std::mutex> lock(switcher->m);
-
-		iter_swap(switcher->sceneSequenceSwitches.begin() + index,
-			  switcher->sceneSequenceSwitches.begin() + index - 1);
-	}
-}
-
-void SceneSwitcher::on_sceneSequenceDown_clicked()
-{
-	int index = ui->sceneSequences->currentRow();
-	if (index != -1 && index != ui->sceneSequences->count() - 1) {
-		ui->sceneSequences->insertItem(
-			index + 1, ui->sceneSequences->takeItem(index));
-		ui->sceneSequences->setCurrentRow(index + 1);
-
-		std::lock_guard<std::mutex> lock(switcher->m);
-
-		iter_swap(switcher->sceneSequenceSwitches.begin() + index,
-			  switcher->sceneSequenceSwitches.begin() + index + 1);
-	}
-}
-
 void SwitcherData::saveSceneSequenceSwitches(obs_data_t *obj)
 {
 	obs_data_array_t *sceneSequenceArray = obs_data_array_create();
 	for (SceneSequenceSwitch &s : switcher->sceneSequenceSwitches) {
 		obs_data_t *array_obj = obs_data_create();
 
-		obs_source_t *source1 =
-			obs_weak_source_get_source(s.startScene);
-		obs_source_t *source2 = obs_weak_source_get_source(s.scene);
-		obs_source_t *transition =
-			obs_weak_source_get_source(s.transition);
-		if (source1 && (s.usePreviousScene || source2) && transition) {
-			const char *sceneName1 = obs_source_get_name(source1);
-			const char *sceneName2 = obs_source_get_name(source2);
-			const char *transitionName =
-				obs_source_get_name(transition);
-			obs_data_set_string(array_obj, "sceneRoundTripScene1",
-					    sceneName1);
-			obs_data_set_string(array_obj, "sceneRoundTripScene2",
-					    s.usePreviousScene
-						    ? previous_scene_name
-						    : sceneName2);
-			obs_data_set_string(array_obj, "transition",
-					    transitionName);
-			obs_data_set_double(array_obj, "delay", s.delay);
-			obs_data_array_push_back(sceneSequenceArray,
-						 array_obj);
-			obs_source_release(source1);
-			obs_source_release(source2);
-			obs_source_release(transition);
-		}
+		s.save(array_obj);
+		obs_data_array_push_back(sceneSequenceArray, array_obj);
 
 		obs_data_release(array_obj);
 	}
@@ -408,100 +253,262 @@ void SwitcherData::loadSceneSequenceSwitches(obs_data_t *obj)
 		obs_data_t *array_obj =
 			obs_data_array_item(sceneSequenceArray, i);
 
-		const char *scene1 =
-			obs_data_get_string(array_obj, "sceneRoundTripScene1");
-		const char *scene2 =
-			obs_data_get_string(array_obj, "sceneRoundTripScene2");
-		const char *transition =
-			obs_data_get_string(array_obj, "transition");
-
-		double delay = 0;
-
-		// To be removed in future version
-		// to be compatible with older versions
-		if (!obs_data_has_user_value(array_obj, "delay")) {
-			delay = double(obs_data_get_int(array_obj,
-							"sceneRoundTripDelay"));
-			delay = delay * 1000. +
-				double(obs_data_get_int(
-					array_obj, "sceneRoundTripDelayMs"));
-			delay /= 1000.;
-		} else {
-			delay = obs_data_get_double(array_obj, "delay");
-		}
-
-		std::string str = MakeSceneSequenceSwitchName(
-					  scene1, scene2, transition, delay)
-					  .toUtf8()
-					  .constData();
-		const char *sceneSequenceStr = str.c_str();
-
-		switcher->sceneSequenceSwitches.emplace_back(
-			GetWeakSourceByName(scene1),
-			GetWeakSourceByName(scene2),
-			GetWeakTransitionByName(transition), delay,
-			(strcmp(scene2, previous_scene_name) == 0),
-			sceneSequenceStr);
+		switcher->sceneSequenceSwitches.emplace_back();
+		sceneSequenceSwitches.back().load(array_obj);
 
 		obs_data_release(array_obj);
 	}
 	obs_data_array_release(sceneSequenceArray);
 }
 
-void SceneSwitcher::setupSequenceTab()
+void AdvSceneSwitcher::setupSequenceTab()
 {
-	populateSceneSelection(ui->sceneSequenceScenes1, false);
-	populateSceneSelection(ui->sceneSequenceScenes2, true);
-	populateTransitionSelection(ui->sceneSequenceTransitions);
-
-	double smallestDelay = double(switcher->interval) / 1000;
 	for (auto &s : switcher->sceneSequenceSwitches) {
-		std::string sceneName1 = GetWeakSourceName(s.startScene);
-		std::string sceneName2 = (s.usePreviousScene)
-						 ? previous_scene_name
-						 : GetWeakSourceName(s.scene);
-		std::string transitionName = GetWeakSourceName(s.transition);
-		QString text = MakeSceneSequenceSwitchName(
-			sceneName1.c_str(), sceneName2.c_str(),
-			transitionName.c_str(), s.delay);
-
-		QListWidgetItem *item =
-			new QListWidgetItem(text, ui->sceneSequences);
-		item->setData(Qt::UserRole, text);
-
-		if (s.delay < smallestDelay)
-			smallestDelay = s.delay;
+		QListWidgetItem *item;
+		item = new QListWidgetItem(ui->sceneSequenceSwitches);
+		ui->sceneSequenceSwitches->addItem(item);
+		SequenceWidget *sw = new SequenceWidget(this, &s);
+		item->setSizeHint(sw->minimumSizeHint());
+		ui->sceneSequenceSwitches->setItemWidget(item, sw);
 	}
-	(smallestDelay * 1000 < switcher->interval)
-		? ui->intervalWarning->setVisible(true)
-		: ui->intervalWarning->setVisible(false);
 
-	ui->sceneSequenceDelayUnits->addItem("seconds");
-	ui->sceneSequenceDelayUnits->addItem("minutes");
-	ui->sceneSequenceDelayUnits->addItem("hours");
+	if (switcher->sceneSequenceSwitches.size() == 0) {
+		addPulse = PulseWidget(ui->sceneSequenceAdd, QColor(Qt::green));
+		ui->sequenceHelp->setVisible(true);
+	} else {
+		ui->sequenceHelp->setVisible(false);
+	}
+}
 
-	switch (switcher->sceneSequenceMultiplier) {
-	case 1:
-		ui->sceneSequenceDelayUnits->setCurrentIndex(0);
+bool SceneSequenceSwitch::initialized()
+{
+	return SceneSwitcherEntry::initialized() && startScene;
+}
+
+bool SceneSequenceSwitch::valid()
+{
+	return !initialized() ||
+	       (SceneSwitcherEntry::valid() && WeakSourceValid(startScene));
+}
+
+void SceneSequenceSwitch::save(obs_data_t *obj)
+{
+	SceneSwitcherEntry::save(obj);
+
+	obs_data_set_string(obj, "startScene",
+			    GetWeakSourceName(startScene).c_str());
+
+	obs_data_set_double(obj, "delay", delay);
+
+	obs_data_set_int(obj, "delayMultiplier", delayMultiplier);
+
+	obs_data_set_bool(obj, "interruptible", interruptible);
+}
+
+// To be removed in future version
+bool loadOldScequence(obs_data_t *obj, SceneSequenceSwitch *s)
+{
+	if (!s) {
+		return false;
+	}
+
+	const char *scene1 = obs_data_get_string(obj, "sceneRoundTripScene1");
+
+	if (strcmp(scene1, "") == 0) {
+		return false;
+	}
+
+	s->startScene = GetWeakSourceByName(scene1);
+
+	const char *scene2 = obs_data_get_string(obj, "sceneRoundTripScene2");
+	s->scene = GetWeakSourceByName(scene2);
+
+	const char *transition = obs_data_get_string(obj, "transition");
+	s->transition = GetWeakTransitionByName(transition);
+
+	s->delay = obs_data_get_double(obj, "delay");
+
+	int delayMultiplier = obs_data_get_int(obj, "delayMultiplier");
+	if (delayMultiplier == 0 ||
+	    (delayMultiplier != 1 && delayMultiplier % 60 != 0))
+		delayMultiplier = 1;
+	s->delayMultiplier = delayMultiplier;
+
+	s->interruptible = obs_data_get_bool(obj, "interruptible");
+
+	s->usePreviousScene = strcmp(scene2, previous_scene_name) == 0;
+
+	return true;
+}
+
+void SceneSequenceSwitch::load(obs_data_t *obj)
+{
+	if (loadOldScequence(obj, this)) {
+		return;
+	}
+
+	SceneSwitcherEntry::load(obj);
+
+	const char *scene = obs_data_get_string(obj, "startScene");
+	startScene = GetWeakSourceByName(scene);
+
+	delay = obs_data_get_double(obj, "delay");
+
+	delayMultiplier = obs_data_get_int(obj, "delayMultiplier");
+	if (delayMultiplier == 0 ||
+	    (delayMultiplier != 1 && delayMultiplier % 60 != 0))
+		delayMultiplier = 1;
+
+	interruptible = obs_data_get_bool(obj, "interruptible");
+}
+
+void populateDelayUnits(QComboBox *list)
+{
+	list->addItem(obs_module_text("AdvSceneSwitcher.unit.secends"));
+	list->addItem(obs_module_text("AdvSceneSwitcher.unit.minutes"));
+	list->addItem(obs_module_text("AdvSceneSwitcher.unit.hours"));
+}
+
+SequenceWidget::SequenceWidget(QWidget *parent, SceneSequenceSwitch *s)
+	: SwitchWidget(parent, s, true, true)
+{
+	delay = new QDoubleSpinBox();
+	delayUnits = new QComboBox();
+	startScenes = new QComboBox();
+	interruptible = new QCheckBox(obs_module_text(
+		"AdvSceneSwitcher.sceneSequenceTab.interruptible"));
+
+	QWidget::connect(delay, SIGNAL(valueChanged(double)), this,
+			 SLOT(DelayChanged(double)));
+	QWidget::connect(delayUnits, SIGNAL(currentIndexChanged(int)), this,
+			 SLOT(DelayUnitsChanged(int)));
+	QWidget::connect(startScenes,
+			 SIGNAL(currentTextChanged(const QString &)), this,
+			 SLOT(StartSceneChanged(const QString &)));
+	QWidget::connect(interruptible, SIGNAL(stateChanged(int)), this,
+			 SLOT(InterruptibleChanged(int)));
+
+	delay->setMaximum(99999.000000);
+	AdvSceneSwitcher::populateSceneSelection(startScenes, false);
+	populateDelayUnits(delayUnits);
+	interruptible->setToolTip(obs_module_text(
+		"AdvSceneSwitcher.sceneSequenceTab.interruptibleHint"));
+
+	if (s) {
+		switch (s->delayMultiplier) {
+		case 1:
+			delayUnits->setCurrentIndex(0);
+			break;
+		case 60:
+			delayUnits->setCurrentIndex(1);
+			break;
+		case 3600:
+			delayUnits->setCurrentIndex(2);
+			break;
+		default:
+			delayUnits->setCurrentIndex(0);
+		}
+		startScenes->setCurrentText(
+			GetWeakSourceName(s->startScene).c_str());
+		interruptible->setChecked(s->interruptible);
+	}
+
+	QHBoxLayout *mainLayout = new QHBoxLayout;
+	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
+		{"{{startScenes}}", startScenes},
+		{"{{scenes}}", scenes},
+		{"{{delay}}", delay},
+		{"{{delayUnits}}", delayUnits},
+		{"{{transitions}}", transitions},
+		{"{{interruptible}}", interruptible}};
+	placeWidgets(obs_module_text("AdvSceneSwitcher.sceneSequenceTab.entry"),
+		     mainLayout, widgetPlaceholders);
+	setLayout(mainLayout);
+
+	switchData = s;
+
+	loading = false;
+
+	UpdateDelay();
+}
+
+SceneSequenceSwitch *SequenceWidget::getSwitchData()
+{
+	return switchData;
+}
+
+void SequenceWidget::setSwitchData(SceneSequenceSwitch *s)
+{
+	switchData = s;
+}
+
+void SequenceWidget::swapSwitchData(SequenceWidget *s1, SequenceWidget *s2)
+{
+	SwitchWidget::swapSwitchData(s1, s2);
+
+	SceneSequenceSwitch *t = s1->getSwitchData();
+	s1->setSwitchData(s2->getSwitchData());
+	s2->setSwitchData(t);
+}
+
+void SequenceWidget::UpdateDelay()
+{
+	if (switchData) {
+		delay->setValue(switchData->delay /
+				switchData->delayMultiplier);
+	}
+}
+
+void SequenceWidget::DelayChanged(double delay)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	switchData->delay = delay * switchData->delayMultiplier;
+}
+
+void SequenceWidget::DelayUnitsChanged(int idx)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	delay_units unit = (delay_units)idx;
+
+	switch (unit) {
+	case SECONDS:
+		switchData->delayMultiplier = 1;
 		break;
-	case 60:
-		ui->sceneSequenceDelayUnits->setCurrentIndex(1);
+	case MINUTES:
+		switchData->delayMultiplier = 60;
 		break;
-	case 3600:
-		ui->sceneSequenceDelayUnits->setCurrentIndex(2);
+	case HOURS:
+		switchData->delayMultiplier = 60 * 60;
 		break;
 	default:
 		break;
 	}
+
+	UpdateDelay();
 }
 
-static inline QString MakeSceneSequenceSwitchName(const QString &scene1,
-						   const QString &scene2,
-						   const QString &transition,
-						   double delay)
+void SequenceWidget::StartSceneChanged(const QString &text)
 {
-	return scene1 + QStringLiteral(" -> wait for ") +
-	       QString::number(delay) + QStringLiteral(" seconds -> ") +
-	       scene2 + QStringLiteral(" (using ") + transition +
-	       QStringLiteral(" transition)");
+	if (loading || !switchData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->startScene = GetWeakSourceByQString(text);
+}
+
+void SequenceWidget::InterruptibleChanged(int state)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->interruptible = state;
 }

src/switch-time.cpp

@@ -1,182 +1,89 @@
 #include "headers/advanced-scene-switcher.hpp"
+#include "headers/utility.hpp"
 
-static std::vector<std::pair<std::string, timeTrigger>> triggerTable = {
-	{"On any day", timeTrigger::ANY_DAY},
-	{"Mondays", timeTrigger::MONDAY},
-	{"Tuesdays", timeTrigger::TUSEDAY},
-	{"Wednesdays", timeTrigger::WEDNESDAY},
-	{"Thursdays", timeTrigger::THURSDAY},
-	{"Fridays", timeTrigger::FRIDAY},
-	{"Saturdays", timeTrigger::SATURDAY},
-	{"Sundays", timeTrigger::SUNDAY},
-	{"Atfer streaming/recording start", timeTrigger::LIVE}};
+bool TimeSwitch::pause = false;
+static QMetaObject::Connection addPulse;
 
-void SceneSwitcher::on_timeSwitches_currentRowChanged(int idx)
+void AdvSceneSwitcher::on_timeAdd_clicked()
 {
-	if (loading)
-		return;
-	if (idx == -1)
-		return;
-
-	QListWidgetItem *item = ui->timeSwitches->item(idx);
-
-	QString timeScenestr = item->data(Qt::UserRole).toString();
-
 	std::lock_guard<std::mutex> lock(switcher->m);
-	for (auto &s : switcher->timeSwitches) {
-		if (timeScenestr.compare(s.timeSwitchStr.c_str()) == 0) {
-			QString sceneName = GetWeakSourceName(s.scene).c_str();
-			QString transitionName =
-				GetWeakSourceName(s.transition).c_str();
-			ui->timeScenes->setCurrentText(sceneName);
-			ui->timeTrigger->setCurrentIndex(s.trigger);
-			ui->timeEdit->setTime(s.time);
-			ui->timeTransitions->setCurrentText(transitionName);
-			break;
-		}
-	}
+	switcher->timeSwitches.emplace_back();
+
+	listAddClicked(ui->timeSwitches,
+		       new TimeSwitchWidget(this,
+					    &switcher->timeSwitches.back()),
+		       ui->timeAdd, &addPulse);
+
+	ui->timeHelp->setVisible(false);
 }
 
-int SceneSwitcher::timeFindByData(const timeTrigger &trigger, const QTime &time)
-{
-	QRegExp rx(MakeTimeSwitchName(QStringLiteral(".*"),
-				      QStringLiteral(".*"), trigger, time));
-	int count = ui->timeSwitches->count();
-
-	for (int i = 0; i < count; i++) {
-		QListWidgetItem *item = ui->timeSwitches->item(i);
-		QString str = item->data(Qt::UserRole).toString();
-
-		if (rx.exactMatch(str))
-			return i;
-	}
-
-	return -1;
-}
-
-void SceneSwitcher::on_timeAdd_clicked()
-{
-	QString sceneName = ui->timeScenes->currentText();
-	QString transitionName = ui->timeTransitions->currentText();
-	QTime time = ui->timeEdit->time();
-
-	if (sceneName.isEmpty())
-		return;
-
-	OBSWeakSource source = GetWeakSourceByQString(sceneName);
-	OBSWeakSource transition = GetWeakTransitionByQString(transitionName);
-
-	std::string triggerStr = ui->timeTrigger->currentText().toStdString();
-	auto it = std::find_if(
-		triggerTable.begin(), triggerTable.end(),
-		[&triggerStr](
-			const std::pair<std::string, timeTrigger> &element) {
-			return element.first == triggerStr;
-		});
-	timeTrigger trigger = it->second;
-
-	QString text =
-		MakeTimeSwitchName(sceneName, transitionName, trigger, time);
-	QVariant v = QVariant::fromValue(text);
-
-	int idx = timeFindByData(trigger, time);
-
-	if (idx == -1) {
-		std::lock_guard<std::mutex> lock(switcher->m);
-		switcher->timeSwitches.emplace_back(
-			source, transition, trigger, time,
-			(sceneName == QString(previous_scene_name)),
-			text.toUtf8().constData());
-
-		QListWidgetItem *item =
-			new QListWidgetItem(text, ui->timeSwitches);
-		item->setData(Qt::UserRole, v);
-	} else {
-		QListWidgetItem *item = ui->timeSwitches->item(idx);
-		item->setText(text);
-		item->setData(Qt::UserRole, v);
-
-		{
-			std::lock_guard<std::mutex> lock(switcher->m);
-			for (auto &s : switcher->timeSwitches) {
-				if (s.trigger == trigger && s.time == time) {
-					s.scene = source;
-					s.transition = transition;
-					s.usePreviousScene =
-						(sceneName ==
-						 QString(previous_scene_name));
-					s.timeSwitchStr =
-						text.toUtf8().constData();
-					break;
-				}
-			}
-		}
-	}
-}
-
-void SceneSwitcher::on_timeRemove_clicked()
+void AdvSceneSwitcher::on_timeRemove_clicked()
 {
 	QListWidgetItem *item = ui->timeSwitches->currentItem();
-	if (!item)
+	if (!item) {
 		return;
-
-	std::string text =
-		item->data(Qt::UserRole).toString().toUtf8().constData();
+	}
 
 	{
 		std::lock_guard<std::mutex> lock(switcher->m);
+		int idx = ui->timeSwitches->currentRow();
 		auto &switches = switcher->timeSwitches;
-
-		for (auto it = switches.begin(); it != switches.end(); ++it) {
-			auto &s = *it;
-
-			if (s.timeSwitchStr == text) {
-				switches.erase(it);
-				break;
-			}
-		}
+		switches.erase(switches.begin() + idx);
 	}
 
 	delete item;
 }
 
-void SceneSwitcher::on_timeUp_clicked()
+void AdvSceneSwitcher::on_timeUp_clicked()
 {
 	int index = ui->timeSwitches->currentRow();
-	if (index != -1 && index != 0) {
-		ui->timeSwitches->insertItem(index - 1,
-					     ui->timeSwitches->takeItem(index));
-		ui->timeSwitches->setCurrentRow(index - 1);
-
-		std::lock_guard<std::mutex> lock(switcher->m);
-
-		iter_swap(switcher->timeSwitches.begin() + index,
-			  switcher->timeSwitches.begin() + index - 1);
+	if (!listMoveUp(ui->timeSwitches)) {
+		return;
 	}
+
+	TimeSwitchWidget *s1 = (TimeSwitchWidget *)ui->timeSwitches->itemWidget(
+		ui->timeSwitches->item(index));
+	TimeSwitchWidget *s2 = (TimeSwitchWidget *)ui->timeSwitches->itemWidget(
+		ui->timeSwitches->item(index - 1));
+	TimeSwitchWidget::swapSwitchData(s1, s2);
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+
+	std::swap(switcher->timeSwitches[index],
+		  switcher->timeSwitches[index - 1]);
 }
 
-void SceneSwitcher::on_timeDown_clicked()
+void AdvSceneSwitcher::on_timeDown_clicked()
 {
 	int index = ui->timeSwitches->currentRow();
-	if (index != -1 && index != ui->timeSwitches->count() - 1) {
-		ui->timeSwitches->insertItem(index + 1,
-					     ui->timeSwitches->takeItem(index));
-		ui->timeSwitches->setCurrentRow(index + 1);
 
-		std::lock_guard<std::mutex> lock(switcher->m);
-
-		iter_swap(switcher->timeSwitches.begin() + index,
-			  switcher->timeSwitches.begin() + index + 1);
+	if (!listMoveDown(ui->timeSwitches)) {
+		return;
 	}
+
+	TimeSwitchWidget *s1 = (TimeSwitchWidget *)ui->timeSwitches->itemWidget(
+		ui->timeSwitches->item(index));
+	TimeSwitchWidget *s2 = (TimeSwitchWidget *)ui->timeSwitches->itemWidget(
+		ui->timeSwitches->item(index + 1));
+	TimeSwitchWidget::swapSwitchData(s1, s2);
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+
+	std::swap(switcher->timeSwitches[index],
+		  switcher->timeSwitches[index + 1]);
 }
 
 bool timesAreInInterval(QTime &time1, QTime &time2, int &interval)
 {
+	if (time1.isNull() || time2.isNull()) {
+		return false;
+	}
+
 	bool ret = false;
 	QTime validSwitchTimeWindow = time1.addMSecs(interval);
 
 	ret = time1 <= time2 && time2 <= validSwitchTimeWindow;
-	// check for overflow
+	// Check for overflow
 	if (!ret && validSwitchTimeWindow.msecsSinceStartOfDay() < interval) {
 		ret = time2 >= time1 || time2 <= validSwitchTimeWindow;
 	}
@@ -185,8 +92,9 @@ bool timesAreInInterval(QTime &time1, QTime &time2, int &interval)
 
 bool checkLiveTime(TimeSwitch &s, QDateTime &start, int &interval)
 {
-	if (start.isNull())
+	if (start.isNull()) {
 		return false;
+	}
 
 	QDateTime now = QDateTime::currentDateTime();
 	QTime timePassed = QTime(0, 0).addMSecs(start.msecsTo(now));
@@ -208,22 +116,29 @@ bool checkRegularTime(TimeSwitch &s, int &interval)
 void SwitcherData::checkTimeSwitch(bool &match, OBSWeakSource &scene,
 				   OBSWeakSource &transition)
 {
-	if (timeSwitches.size() == 0)
+	if (TimeSwitch::pause) {
 		return;
+	}
 
 	for (TimeSwitch &s : timeSwitches) {
-		if (s.trigger == LIVE)
+		if (!s.initialized()) {
+			continue;
+		}
+
+		if (s.trigger == LIVE) {
 			match = checkLiveTime(s, liveTime, interval);
-		else
+		} else {
 			match = checkRegularTime(s, interval);
+		}
 
 		if (match) {
-			scene = (s.usePreviousScene) ? previousScene : s.scene;
+			scene = s.getScene();
 			transition = s.transition;
 			match = true;
 
-			if (verbose)
+			if (verbose) {
 				s.logMatch();
+			}
 			break;
 		}
 	}
@@ -235,28 +150,8 @@ void SwitcherData::saveTimeSwitches(obs_data_t *obj)
 	for (TimeSwitch &s : switcher->timeSwitches) {
 		obs_data_t *array_obj = obs_data_create();
 
-		obs_source_t *sceneSource = obs_weak_source_get_source(s.scene);
-		obs_source_t *transition =
-			obs_weak_source_get_source(s.transition);
-		if ((s.usePreviousScene || sceneSource) && transition) {
-			const char *sceneName =
-				obs_source_get_name(sceneSource);
-			const char *transitionName =
-				obs_source_get_name(transition);
-			obs_data_set_string(array_obj, "scene",
-					    s.usePreviousScene
-						    ? previous_scene_name
-						    : sceneName);
-			obs_data_set_string(array_obj, "transition",
-					    transitionName);
-			obs_data_set_int(array_obj, "trigger", s.trigger);
-			obs_data_set_string(
-				array_obj, "time",
-				s.time.toString().toStdString().c_str());
-			obs_data_array_push_back(timeArray, array_obj);
-		}
-		obs_source_release(sceneSource);
-		obs_source_release(transition);
+		s.save(array_obj);
+		obs_data_array_push_back(timeArray, array_obj);
 
 		obs_data_release(array_obj);
 	}
@@ -274,99 +169,165 @@ void SwitcherData::loadTimeSwitches(obs_data_t *obj)
 	for (size_t i = 0; i < count; i++) {
 		obs_data_t *array_obj = obs_data_array_item(timeArray, i);
 
-		const char *scene = obs_data_get_string(array_obj, "scene");
-		const char *transition =
-			obs_data_get_string(array_obj, "transition");
-		timeTrigger trigger =
-			(timeTrigger)obs_data_get_int(array_obj, "trigger");
-		QTime time = QTime::fromString(
-			obs_data_get_string(array_obj, "time"));
-
-		std::string timeSwitchStr =
-			MakeTimeSwitchName(scene, transition, trigger, time)
-				.toUtf8()
-				.constData();
-
-		switcher->timeSwitches.emplace_back(
-			GetWeakSourceByName(scene),
-			GetWeakTransitionByName(transition), trigger, time,
-			(strcmp(scene, previous_scene_name) == 0),
-			timeSwitchStr);
+		switcher->timeSwitches.emplace_back();
+		timeSwitches.back().load(array_obj);
 
 		obs_data_release(array_obj);
 	}
 	obs_data_array_release(timeArray);
 }
 
-void SceneSwitcher::setupTimeTab()
+void AdvSceneSwitcher::setupTimeTab()
 {
-	populateSceneSelection(ui->timeScenes, true);
-	populateTransitionSelection(ui->timeTransitions);
-
-	for (auto t : triggerTable) {
-		ui->timeTrigger->addItem(t.first.c_str());
-	}
-
-	// assuming the streaming / recording entry is always last
-	ui->timeTrigger->setItemData(
-		(int)triggerTable.size() - 1,
-		"The time relative to the start of streaming / recording will be used",
-		Qt::ToolTipRole);
-
 	for (auto &s : switcher->timeSwitches) {
-		std::string sceneName = (s.usePreviousScene)
-						? previous_scene_name
-						: GetWeakSourceName(s.scene);
-		std::string transitionName = GetWeakSourceName(s.transition);
-		QString listText = MakeTimeSwitchName(sceneName.c_str(),
-						      transitionName.c_str(),
-						      s.trigger, s.time);
+		QListWidgetItem *item;
+		item = new QListWidgetItem(ui->timeSwitches);
+		ui->timeSwitches->addItem(item);
+		TimeSwitchWidget *sw = new TimeSwitchWidget(this, &s);
+		item->setSizeHint(sw->minimumSizeHint());
+		ui->timeSwitches->setItemWidget(item, sw);
+	}
 
-		QListWidgetItem *item =
-			new QListWidgetItem(listText, ui->timeSwitches);
-		item->setData(Qt::UserRole, listText);
+	if (switcher->timeSwitches.size() == 0) {
+		addPulse = PulseWidget(ui->timeAdd, QColor(Qt::green));
+		ui->timeHelp->setVisible(true);
+	} else {
+		ui->timeHelp->setVisible(false);
 	}
 }
 
-static inline QString MakeTimeSwitchName(const QString &scene,
-					 const QString &transition,
-					 const timeTrigger &trigger,
-					 const QTime &time)
+void TimeSwitch::save(obs_data_t *obj)
 {
-	QString switchName;
+	SceneSwitcherEntry::save(obj);
 
-	switch (trigger) {
-	case ANY_DAY:
-		switchName = QStringLiteral("On any weekday");
-		break;
-	case MONDAY:
-		switchName = QStringLiteral("Mondays");
-		break;
-	case TUSEDAY:
-		switchName = QStringLiteral("Tusedays");
-		break;
-	case WEDNESDAY:
-		switchName = QStringLiteral("Wednesdays");
-		break;
-	case THURSDAY:
-		switchName = QStringLiteral("Thursdays");
-		break;
-	case FRIDAY:
-		switchName = QStringLiteral("Fridays");
-		break;
-	case SATURDAY:
-		switchName = QStringLiteral("Saturdays");
-		break;
-	case SUNDAY:
-		switchName = QStringLiteral("Sundays");
-		break;
-	case LIVE:
-		switchName = QStringLiteral(
-			"Relative to starting streaming / recording");
-		break;
-	}
-	switchName += QStringLiteral(" at ") + time.toString() +
-		      QStringLiteral(" switch to ") + scene +
-		      QStringLiteral(" using ") + transition;
-	return switchName;
+	obs_data_set_int(obj, "trigger", trigger);
+	obs_data_set_string(obj, "time", time.toString().toStdString().c_str());
+}
+
+// To be removed in future version
+bool loadOldTime(obs_data_t *obj, TimeSwitch *s)
+{
+	if (!s) {
+		return false;
+	}
+
+	const char *scene = obs_data_get_string(obj, "scene");
+
+	if (strcmp(scene, "") == 0) {
+		return false;
+	}
+
+	s->scene = GetWeakSourceByName(scene);
+
+	const char *transition = obs_data_get_string(obj, "transition");
+	s->transition = GetWeakTransitionByName(transition);
+
+	s->trigger = (timeTrigger)obs_data_get_int(obj, "trigger");
+	s->time = QTime::fromString(obs_data_get_string(obj, "time"));
+	s->usePreviousScene = strcmp(scene, previous_scene_name) == 0;
+
+	return true;
+}
+
+void TimeSwitch::load(obs_data_t *obj)
+{
+	if (loadOldTime(obj, this)) {
+		return;
+	}
+
+	SceneSwitcherEntry::load(obj);
+
+	trigger = (timeTrigger)obs_data_get_int(obj, "trigger");
+	time = QTime::fromString(obs_data_get_string(obj, "time"));
+}
+
+inline void populateTriggers(QComboBox *list)
+{
+	list->addItem(obs_module_text("AdvSceneSwitcher.timeTab.anyDay"));
+	list->addItem(obs_module_text("AdvSceneSwitcher.timeTab.mondays"));
+	list->addItem(obs_module_text("AdvSceneSwitcher.timeTab.tuesdays"));
+	list->addItem(obs_module_text("AdvSceneSwitcher.timeTab.wednesdays"));
+	list->addItem(obs_module_text("AdvSceneSwitcher.timeTab.thursdays"));
+	list->addItem(obs_module_text("AdvSceneSwitcher.timeTab.fridays"));
+	list->addItem(obs_module_text("AdvSceneSwitcher.timeTab.saturdays"));
+	list->addItem(obs_module_text("AdvSceneSwitcher.timeTab.sundays"));
+	list->addItem(obs_module_text("AdvSceneSwitcher.timeTab.afterstart"));
+
+	list->setItemData(
+		8, obs_module_text("AdvSceneSwitcher.timeTab.afterstart.tip"),
+		Qt::ToolTipRole);
+}
+
+TimeSwitchWidget::TimeSwitchWidget(QWidget *parent, TimeSwitch *s)
+	: SwitchWidget(parent, s, true, true)
+{
+	triggers = new QComboBox();
+	time = new QTimeEdit();
+
+	QWidget::connect(triggers, SIGNAL(currentIndexChanged(int)), this,
+			 SLOT(TriggerChanged(int)));
+	QWidget::connect(time, SIGNAL(timeChanged(const QTime &)), this,
+			 SLOT(TimeChanged(const QTime &)));
+
+	populateTriggers(triggers);
+	time->setDisplayFormat("HH:mm:ss");
+
+	if (s) {
+		triggers->setCurrentIndex(s->trigger);
+		time->setTime(s->time);
+	}
+
+	QHBoxLayout *mainLayout = new QHBoxLayout;
+	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
+		{"{{triggers}}", triggers},
+		{"{{time}}", time},
+		{"{{scenes}}", scenes},
+		{"{{transitions}}", transitions}};
+	placeWidgets(obs_module_text("AdvSceneSwitcher.timeTab.entry"),
+		     mainLayout, widgetPlaceholders);
+	setLayout(mainLayout);
+
+	switchData = s;
+
+	loading = false;
+}
+
+TimeSwitch *TimeSwitchWidget::getSwitchData()
+{
+	return switchData;
+}
+
+void TimeSwitchWidget::setSwitchData(TimeSwitch *s)
+{
+	switchData = s;
+}
+
+void TimeSwitchWidget::swapSwitchData(TimeSwitchWidget *s1,
+				      TimeSwitchWidget *s2)
+{
+	SwitchWidget::swapSwitchData(s1, s2);
+
+	TimeSwitch *t = s1->getSwitchData();
+	s1->setSwitchData(s2->getSwitchData());
+	s2->setSwitchData(t);
+}
+
+void TimeSwitchWidget::TriggerChanged(int index)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->trigger = (timeTrigger)index;
+}
+
+void TimeSwitchWidget::TimeChanged(const QTime &time)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->time = time;
 }

src/switch-transitions.cpp

@@ -1,278 +1,197 @@
 #include "headers/advanced-scene-switcher.hpp"
+#include "headers/utility.hpp"
 
-void SceneSwitcher::on_transitionsAdd_clicked()
+bool DefaultSceneTransition::pause = false;
+
+void AdvSceneSwitcher::on_transitionsAdd_clicked()
 {
-	QString scene1Name = ui->transitionsScene1->currentText();
-	QString scene2Name = ui->transitionsScene2->currentText();
-	QString transitionName = ui->transitionsTransitions->currentText();
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switcher->sceneTransitions.emplace_back();
 
-	if (scene1Name.isEmpty() || scene2Name.isEmpty())
-		return;
+	listAddClicked(ui->sceneTransitions,
+		       new TransitionSwitchWidget(
+			       this, &switcher->sceneTransitions.back()));
 
-	if (scene1Name == scene2Name)
-		return;
-
-	OBSWeakSource source1 = GetWeakSourceByQString(scene1Name);
-	OBSWeakSource source2 = GetWeakSourceByQString(scene2Name);
-	OBSWeakSource transition = GetWeakTransitionByQString(transitionName);
-
-	QString text =
-		MakeSceneTransitionName(scene1Name, scene2Name, transitionName);
-	QVariant v = QVariant::fromValue(text);
-
-	int idx = SceneTransitionsFindByData(scene1Name, scene2Name);
-
-	if (idx == -1) {
-		QListWidgetItem *item =
-			new QListWidgetItem(text, ui->sceneTransitions);
-		item->setData(Qt::UserRole, v);
-
-		std::lock_guard<std::mutex> lock(switcher->m);
-		switcher->sceneTransitions.emplace_back(
-			source1, source2, transition,
-			text.toUtf8().constData());
-	} else {
-		QListWidgetItem *item = ui->sceneTransitions->item(idx);
-		item->setText(text);
-
-		{
-			std::lock_guard<std::mutex> lock(switcher->m);
-			for (auto &s : switcher->sceneTransitions) {
-				if (s.scene == source1 && s.scene2 == source2) {
-					s.transition = transition;
-					s.sceneTransitionStr =
-						text.toUtf8().constData();
-					break;
-				}
-			}
-		}
-
-		ui->sceneTransitions->sortItems();
-	}
+	ui->transitionHelp->setVisible(false);
 }
 
-void SceneSwitcher::on_transitionsRemove_clicked()
+void AdvSceneSwitcher::on_transitionsRemove_clicked()
 {
 	QListWidgetItem *item = ui->sceneTransitions->currentItem();
-	if (!item)
+	if (!item) {
 		return;
-
-	std::string text =
-		item->data(Qt::UserRole).toString().toUtf8().constData();
+	}
 
 	{
 		std::lock_guard<std::mutex> lock(switcher->m);
+		int idx = ui->sceneTransitions->currentRow();
 		auto &switches = switcher->sceneTransitions;
-
-		for (auto it = switches.begin(); it != switches.end(); ++it) {
-			auto &s = *it;
-
-			if (s.sceneTransitionStr == text) {
-				switches.erase(it);
-				break;
-			}
-		}
+		switches.erase(switches.begin() + idx);
 	}
 
 	delete item;
 }
 
-void SceneSwitcher::on_defaultTransitionsAdd_clicked()
+void AdvSceneSwitcher::on_transitionsUp_clicked()
 {
-	QString sceneName = ui->defaultTransitionsScene->currentText();
-	QString transitionName =
-		ui->defaultTransitionsTransitions->currentText();
-
-	if (sceneName.isEmpty() || transitionName.isEmpty())
+	int index = ui->sceneTransitions->currentRow();
+	if (!listMoveUp(ui->sceneTransitions)) {
 		return;
-
-	OBSWeakSource source = GetWeakSourceByQString(sceneName);
-	OBSWeakSource transition = GetWeakTransitionByQString(transitionName);
-
-	QString text =
-		MakeDefaultSceneTransitionName(sceneName, transitionName);
-	QVariant v = QVariant::fromValue(text);
-
-	int idx = DefaultTransitionsFindByData(sceneName);
-
-	if (idx == -1) {
-		QListWidgetItem *item =
-			new QListWidgetItem(text, ui->defaultTransitions);
-		item->setData(Qt::UserRole, v);
-
-		std::lock_guard<std::mutex> lock(switcher->m);
-		switcher->defaultSceneTransitions.emplace_back(
-			source, transition, text.toUtf8().constData());
-	} else {
-		QListWidgetItem *item = ui->defaultTransitions->item(idx);
-		item->setText(text);
-
-		{
-			std::lock_guard<std::mutex> lock(switcher->m);
-			for (auto &s : switcher->defaultSceneTransitions) {
-				if (s.scene == source) {
-					s.transition = transition;
-					s.sceneTransitionStr =
-						text.toUtf8().constData();
-					break;
-				}
-			}
-		}
-
-		ui->defaultTransitions->sortItems();
 	}
+
+	TransitionSwitchWidget *s1 =
+		(TransitionSwitchWidget *)ui->sceneTransitions->itemWidget(
+			ui->sceneTransitions->item(index));
+	TransitionSwitchWidget *s2 =
+		(TransitionSwitchWidget *)ui->sceneTransitions->itemWidget(
+			ui->sceneTransitions->item(index - 1));
+	TransitionSwitchWidget::swapSwitchData(s1, s2);
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+
+	std::swap(switcher->sceneTransitions[index],
+		  switcher->sceneTransitions[index - 1]);
 }
 
-void SceneSwitcher::on_defaultTransitionsRemove_clicked()
+void AdvSceneSwitcher::on_transitionsDown_clicked()
+{
+	int index = ui->sceneTransitions->currentRow();
+
+	if (!listMoveDown(ui->sceneTransitions)) {
+		return;
+	}
+
+	TransitionSwitchWidget *s1 =
+		(TransitionSwitchWidget *)ui->sceneTransitions->itemWidget(
+			ui->sceneTransitions->item(index));
+	TransitionSwitchWidget *s2 =
+		(TransitionSwitchWidget *)ui->sceneTransitions->itemWidget(
+			ui->sceneTransitions->item(index + 1));
+	TransitionSwitchWidget::swapSwitchData(s1, s2);
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+
+	std::swap(switcher->sceneTransitions[index],
+		  switcher->sceneTransitions[index + 1]);
+}
+
+void AdvSceneSwitcher::on_defaultTransitionsAdd_clicked()
+{
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switcher->defaultSceneTransitions.emplace_back();
+
+	listAddClicked(ui->defaultTransitions,
+		       new DefTransitionSwitchWidget(
+			       this,
+			       &switcher->defaultSceneTransitions.back()));
+
+	ui->defaultTransitionHelp->setVisible(false);
+}
+
+void AdvSceneSwitcher::on_defaultTransitionsRemove_clicked()
 {
 	QListWidgetItem *item = ui->defaultTransitions->currentItem();
-	if (!item)
+	if (!item) {
 		return;
-
-	std::string text =
-		item->data(Qt::UserRole).toString().toUtf8().constData();
+	}
 
 	{
 		std::lock_guard<std::mutex> lock(switcher->m);
+		int idx = ui->defaultTransitions->currentRow();
 		auto &switches = switcher->defaultSceneTransitions;
-
-		for (auto it = switches.begin(); it != switches.end(); ++it) {
-			auto &s = *it;
-
-			if (s.sceneTransitionStr == text) {
-				switches.erase(it);
-				break;
-			}
-		}
+		switches.erase(switches.begin() + idx);
 	}
 
 	delete item;
 }
 
-void SwitcherData::setDefaultSceneTransitions()
+void AdvSceneSwitcher::on_defaultTransitionsUp_clicked()
 {
+	int index = ui->defaultTransitions->currentRow();
+	if (!listMoveUp(ui->defaultTransitions)) {
+		return;
+	}
+
+	TransitionSwitchWidget *s1 =
+		(TransitionSwitchWidget *)ui->defaultTransitions->itemWidget(
+			ui->defaultTransitions->item(index));
+	TransitionSwitchWidget *s2 =
+		(TransitionSwitchWidget *)ui->defaultTransitions->itemWidget(
+			ui->defaultTransitions->item(index - 1));
+	TransitionSwitchWidget::swapSwitchData(s1, s2);
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+
+	std::swap(switcher->defaultSceneTransitions[index],
+		  switcher->defaultSceneTransitions[index - 1]);
+}
+
+void AdvSceneSwitcher::on_defaultTransitionsDown_clicked()
+{
+	int index = ui->defaultTransitions->currentRow();
+
+	if (!listMoveDown(ui->defaultTransitions)) {
+		return;
+	}
+
+	DefTransitionSwitchWidget *s1 =
+		(DefTransitionSwitchWidget *)ui->defaultTransitions->itemWidget(
+			ui->defaultTransitions->item(index));
+	DefTransitionSwitchWidget *s2 =
+		(DefTransitionSwitchWidget *)ui->defaultTransitions->itemWidget(
+			ui->defaultTransitions->item(index + 1));
+	DefTransitionSwitchWidget::swapSwitchData(s1, s2);
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+
+	std::swap(switcher->defaultSceneTransitions[index],
+		  switcher->defaultSceneTransitions[index + 1]);
+}
+
+void SwitcherData::checkDefaultSceneTransitions(bool &match,
+						OBSWeakSource &transition)
+{
+	if (checkedDefTransition || DefaultSceneTransition::pause) {
+		return;
+	}
+
 	obs_source_t *currentSource = obs_frontend_get_current_scene();
 	obs_weak_source_t *ws = obs_source_get_weak_source(currentSource);
 
 	for (DefaultSceneTransition &s : defaultSceneTransitions) {
 		if (s.scene == ws) {
-			obs_source_t *transition =
-				obs_weak_source_get_source(s.transition);
-			//This might cancel the current transition
-			//There is no way to be sure when the previous transition finished
-			obs_frontend_set_current_transition(transition);
+			if (!s.initialized()) {
+				continue;
+			}
 
-			if (verbose)
-				if (verbose)
-					s.logMatch();
+			match = true;
+			transition = s.transition;
 
-			obs_source_release(transition);
+			if (verbose) {
+				s.logMatch();
+			}
 			break;
 		}
 	}
 	obs_source_release(currentSource);
 	obs_weak_source_release(ws);
+
+	checkedDefTransition = true;
 }
 
-int SceneSwitcher::SceneTransitionsFindByData(const QString &scene1,
-					      const QString &scene2)
+void SwitcherData::setCurrentDefTransition(OBSWeakSource &transition)
 {
-	QRegExp rx(scene1 + " --- .* --> " + scene2);
-	int count = ui->sceneTransitions->count();
-	int idx = -1;
+	obs_source_t *transitionSource = obs_weak_source_get_source(transition);
+	obs_frontend_set_current_transition(transitionSource);
+	obs_source_release(transitionSource);
+}
 
-	for (int i = 0; i < count; i++) {
-		QListWidgetItem *item = ui->sceneTransitions->item(i);
-		QString itemString = item->data(Qt::UserRole).toString();
-
-		if (rx.exactMatch(itemString)) {
-			idx = i;
-			break;
-		}
+void AdvSceneSwitcher::on_transitionOverridecheckBox_stateChanged(int state)
+{
+	if (loading) {
+		return;
 	}
 
-	return idx;
-}
-
-int SceneSwitcher::DefaultTransitionsFindByData(const QString &scene)
-{
-	QRegExp rx(scene + " --> .*");
-	int count = ui->defaultTransitions->count();
-	int idx = -1;
-
-	for (int i = 0; i < count; i++) {
-		QListWidgetItem *item = ui->defaultTransitions->item(i);
-		QString itemString = item->data(Qt::UserRole).toString();
-
-		if (rx.exactMatch(itemString)) {
-			idx = i;
-			break;
-		}
-	}
-
-	return idx;
-}
-
-void SceneSwitcher::on_sceneTransitions_currentRowChanged(int idx)
-{
-	if (loading)
-		return;
-	if (idx == -1)
-		return;
-
-	QListWidgetItem *item = ui->sceneTransitions->item(idx);
-
-	QString sceneTransition = item->data(Qt::UserRole).toString();
-
-	std::lock_guard<std::mutex> lock(switcher->m);
-	for (auto &s : switcher->sceneTransitions) {
-		if (sceneTransition.compare(s.sceneTransitionStr.c_str()) ==
-		    0) {
-			std::string scene1 = GetWeakSourceName(s.scene);
-			std::string scene2 = GetWeakSourceName(s.scene2);
-			std::string transitionName =
-				GetWeakSourceName(s.transition);
-			ui->transitionsScene1->setCurrentText(scene1.c_str());
-			ui->transitionsScene2->setCurrentText(scene2.c_str());
-			ui->transitionsTransitions->setCurrentText(
-				transitionName.c_str());
-			break;
-		}
-	}
-}
-
-void SceneSwitcher::on_defaultTransitions_currentRowChanged(int idx)
-{
-	if (loading)
-		return;
-	if (idx == -1)
-		return;
-
-	QListWidgetItem *item = ui->defaultTransitions->item(idx);
-
-	QString sceneTransition = item->data(Qt::UserRole).toString();
-
-	std::lock_guard<std::mutex> lock(switcher->m);
-	for (auto &s : switcher->defaultSceneTransitions) {
-		if (sceneTransition.compare(s.sceneTransitionStr.c_str()) ==
-		    0) {
-			std::string scene = GetWeakSourceName(s.scene);
-			std::string transitionName =
-				GetWeakSourceName(s.transition);
-			ui->defaultTransitionsScene->setCurrentText(
-				scene.c_str());
-			ui->defaultTransitionsTransitions->setCurrentText(
-				transitionName.c_str());
-			break;
-		}
-	}
-}
-
-void SceneSwitcher::on_transitionOverridecheckBox_stateChanged(int state)
-{
-	if (loading)
-		return;
-
 	std::lock_guard<std::mutex> lock(switcher->m);
 	if (!state) {
 		switcher->tansitionOverrideOverride = false;
@@ -287,8 +206,14 @@ obs_weak_source_t *getNextTransition(obs_weak_source_t *scene1,
 	obs_weak_source_t *ws = nullptr;
 	if (scene1 && scene2) {
 		for (SceneTransition &t : switcher->sceneTransitions) {
-			if (t.scene == scene1 && t.scene2 == scene2)
+			if (!t.initialized()) {
+				continue;
+			}
+
+			if (t.scene == scene1 && t.scene2 == scene2) {
 				ws = t.transition;
+				break;
+			}
 		}
 		obs_weak_source_addref(ws);
 	}
@@ -345,8 +270,9 @@ void setNextTransition(OBSWeakSource &targetScene, obs_source_t *currentSource,
 		obs_frontend_set_current_transition(nextTransition);
 	}
 
-	if (transitionOverrideOverride)
+	if (transitionOverrideOverride) {
 		overwriteTransitionOverride(targetScene, nextTransition, td);
+	}
 
 	obs_weak_source_release(nextTransitionWs);
 	obs_source_release(nextTransition);
@@ -373,11 +299,10 @@ void SwitcherData::saveSceneTransitions(obs_data_t *obj)
 					    transitionName);
 			obs_data_array_push_back(sceneTransitionsArray,
 						 array_obj);
-			obs_source_release(source1);
-			obs_source_release(source2);
-			obs_source_release(transition);
 		}
-
+		obs_source_release(source1);
+		obs_source_release(source2);
+		obs_source_release(transition);
 		obs_data_release(array_obj);
 	}
 	obs_data_set_array(obj, "sceneTransitions", sceneTransitionsArray);
@@ -399,10 +324,9 @@ void SwitcherData::saveSceneTransitions(obs_data_t *obj)
 					    transitionName);
 			obs_data_array_push_back(defaultTransitionsArray,
 						 array_obj);
-			obs_source_release(source);
-			obs_source_release(transition);
 		}
-
+		obs_source_release(source);
+		obs_source_release(transition);
 		obs_data_release(array_obj);
 	}
 	obs_data_set_array(obj, "defaultTransitions", defaultTransitionsArray);
@@ -429,16 +353,10 @@ void SwitcherData::loadSceneTransitions(obs_data_t *obj)
 		const char *transition =
 			obs_data_get_string(array_obj, "transition");
 
-		std::string sceneTransitionsStr =
-			MakeSceneTransitionName(scene1, scene2, transition)
-				.toUtf8()
-				.constData();
-
 		switcher->sceneTransitions.emplace_back(
 			GetWeakSourceByName(scene1),
 			GetWeakSourceByName(scene2),
-			GetWeakTransitionByName(transition),
-			sceneTransitionsStr);
+			GetWeakTransitionByName(transition));
 
 		obs_data_release(array_obj);
 	}
@@ -458,15 +376,9 @@ void SwitcherData::loadSceneTransitions(obs_data_t *obj)
 		const char *transition =
 			obs_data_get_string(array_obj, "transition");
 
-		std::string sceneTransitionsStr =
-			MakeDefaultSceneTransitionName(scene, transition)
-				.toUtf8()
-				.constData();
-
 		switcher->defaultSceneTransitions.emplace_back(
 			GetWeakSourceByName(scene),
-			GetWeakTransitionByName(transition),
-			sceneTransitionsStr);
+			GetWeakTransitionByName(transition));
 
 		obs_data_release(array_obj);
 	}
@@ -476,52 +388,148 @@ void SwitcherData::loadSceneTransitions(obs_data_t *obj)
 		obs_data_get_bool(obj, "tansitionOverrideOverride");
 }
 
-void SceneSwitcher::setupTransitionsTab()
+void AdvSceneSwitcher::setupTransitionsTab()
 {
-	populateSceneSelection(ui->transitionsScene1, false);
-	populateSceneSelection(ui->transitionsScene2, false);
-	populateSceneSelection(ui->defaultTransitionsScene, false);
-	populateTransitionSelection(ui->transitionsTransitions);
-	populateTransitionSelection(ui->defaultTransitionsTransitions);
-
 	for (auto &s : switcher->sceneTransitions) {
-		std::string sceneName1 = GetWeakSourceName(s.scene);
-		std::string sceneName2 = GetWeakSourceName(s.scene2);
-		std::string transitionName = GetWeakSourceName(s.transition);
-		QString text = MakeSceneTransitionName(sceneName1.c_str(),
-						       sceneName2.c_str(),
-						       transitionName.c_str());
+		QListWidgetItem *item;
+		item = new QListWidgetItem(ui->sceneTransitions);
+		ui->sceneTransitions->addItem(item);
+		TransitionSwitchWidget *sw =
+			new TransitionSwitchWidget(this, &s);
+		item->setSizeHint(sw->minimumSizeHint());
+		ui->sceneTransitions->setItemWidget(item, sw);
+	}
 
-		QListWidgetItem *item =
-			new QListWidgetItem(text, ui->sceneTransitions);
-		item->setData(Qt::UserRole, text);
+	if (switcher->sceneTransitions.size() == 0) {
+		ui->transitionHelp->setVisible(true);
+	} else {
+		ui->transitionHelp->setVisible(false);
 	}
 
 	for (auto &s : switcher->defaultSceneTransitions) {
-		std::string sceneName = GetWeakSourceName(s.scene);
-		std::string transitionName = GetWeakSourceName(s.transition);
-		QString text = MakeDefaultSceneTransitionName(
-			sceneName.c_str(), transitionName.c_str());
+		QListWidgetItem *item;
+		item = new QListWidgetItem(ui->defaultTransitions);
+		ui->defaultTransitions->addItem(item);
+		DefTransitionSwitchWidget *sw =
+			new DefTransitionSwitchWidget(this, &s);
+		item->setSizeHint(sw->minimumSizeHint());
+		ui->defaultTransitions->setItemWidget(item, sw);
+	}
 
-		QListWidgetItem *item =
-			new QListWidgetItem(text, ui->defaultTransitions);
-		item->setData(Qt::UserRole, text);
+	if (switcher->defaultSceneTransitions.size() == 0) {
+		ui->defaultTransitionHelp->setVisible(true);
+	} else {
+		ui->defaultTransitionHelp->setVisible(false);
 	}
 
 	ui->transitionOverridecheckBox->setChecked(
 		switcher->tansitionOverrideOverride);
 }
 
-static inline QString MakeSceneTransitionName(const QString &scene1,
-					      const QString &scene2,
-					      const QString &transition)
+bool SceneTransition::initialized()
 {
-	return scene1 + QStringLiteral(" --- ") + transition +
-	       QStringLiteral(" --> ") + scene2;
+	return SceneSwitcherEntry::initialized() && scene2;
 }
 
-static inline QString MakeDefaultSceneTransitionName(const QString &scene,
-						     const QString &transition)
+bool SceneTransition::valid()
 {
-	return scene + QStringLiteral(" --> ") + transition;
+	return !initialized() ||
+	       (SceneSwitcherEntry::valid() && WeakSourceValid(scene2));
+}
+
+TransitionSwitchWidget::TransitionSwitchWidget(QWidget *parent,
+					       SceneTransition *s)
+	: SwitchWidget(parent, s, false)
+{
+	scenes2 = new QComboBox();
+
+	QWidget::connect(scenes2, SIGNAL(currentTextChanged(const QString &)),
+			 this, SLOT(Scene2Changed(const QString &)));
+
+	AdvSceneSwitcher::populateSceneSelection(scenes2, false);
+
+	if (s) {
+		scenes2->setCurrentText(GetWeakSourceName(s->scene2).c_str());
+	}
+
+	QHBoxLayout *mainLayout = new QHBoxLayout;
+	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
+		{"{{scenes}}", scenes},
+		{"{{scenes2}}", scenes2},
+		{"{{transitions}}", transitions}};
+	placeWidgets(obs_module_text("AdvSceneSwitcher.transitionTab.entry"),
+		     mainLayout, widgetPlaceholders);
+	setLayout(mainLayout);
+
+	switchData = s;
+
+	loading = false;
+}
+
+SceneTransition *TransitionSwitchWidget::getSwitchData()
+{
+	return switchData;
+}
+
+void TransitionSwitchWidget::setSwitchData(SceneTransition *s)
+{
+	switchData = s;
+}
+
+void TransitionSwitchWidget::swapSwitchData(TransitionSwitchWidget *s1,
+					    TransitionSwitchWidget *s2)
+{
+	SwitchWidget::swapSwitchData(s1, s2);
+
+	SceneTransition *t = s1->getSwitchData();
+	s1->setSwitchData(s2->getSwitchData());
+	s2->setSwitchData(t);
+}
+
+void TransitionSwitchWidget::Scene2Changed(const QString &text)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->scene2 = GetWeakSourceByQString(text);
+}
+
+DefTransitionSwitchWidget::DefTransitionSwitchWidget(QWidget *parent,
+						     DefaultSceneTransition *s)
+	: SwitchWidget(parent, s, false)
+{
+	QHBoxLayout *mainLayout = new QHBoxLayout;
+	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
+		{"{{scenes}}", scenes}, {"{{transitions}}", transitions}};
+	placeWidgets(
+		obs_module_text(
+			"AdvSceneSwitcher.transitionTab.defaultTransitionEntry"),
+		mainLayout, widgetPlaceholders);
+	setLayout(mainLayout);
+
+	switchData = s;
+
+	loading = false;
+}
+
+DefaultSceneTransition *DefTransitionSwitchWidget::getSwitchData()
+{
+	return switchData;
+}
+
+void DefTransitionSwitchWidget::setSwitchData(DefaultSceneTransition *s)
+{
+	switchData = s;
+}
+
+void DefTransitionSwitchWidget::swapSwitchData(DefTransitionSwitchWidget *s1,
+					       DefTransitionSwitchWidget *s2)
+{
+	SwitchWidget::swapSwitchData(s1, s2);
+
+	DefaultSceneTransition *t = s1->getSwitchData();
+	s1->setSwitchData(s2->getSwitchData());
+	s2->setSwitchData(t);
 }

src/switch-window.cpp

@@ -1,147 +1,91 @@
+#include <regex>
+
 #include "headers/advanced-scene-switcher.hpp"
+#include "headers/utility.hpp"
 
-bool isRunning(std::string &title)
+bool WindowSwitch::pause = false;
+static QMetaObject::Connection addPulse;
+
+void AdvSceneSwitcher::on_windowAdd_clicked()
 {
-	QStringList windows;
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switcher->windowSwitches.emplace_back();
 
-	GetWindowList(windows);
-	// True if switch is running (direct)
-	bool equals = windows.contains(QString::fromStdString(title));
-	// True if switch is running (regex)
-	bool matches = (windows.indexOf(QRegularExpression(
-				QString::fromStdString(title))) != -1);
+	listAddClicked(ui->windowSwitches,
+		       new WindowSwitchWidget(this,
+					      &switcher->windowSwitches.back()),
+		       ui->windowAdd, &addPulse);
 
-	return (equals || matches);
+	ui->windowHelp->setVisible(false);
 }
 
-bool isFocused(std::string &title)
+void AdvSceneSwitcher::on_windowRemove_clicked()
 {
-	std::string current;
-
-	GetCurrentWindowTitle(current);
-	// True if switch equals current window
-	bool equals = (title == current);
-	// True if switch matches current window
-	bool matches = QString::fromStdString(current).contains(
-		QRegularExpression(QString::fromStdString(title)));
-
-	return (equals || matches);
-}
-
-void SceneSwitcher::on_up_clicked()
-{
-	int index = ui->switches->currentRow();
-	if (index != -1 && index != 0) {
-		ui->switches->insertItem(index - 1,
-					 ui->switches->takeItem(index));
-		ui->switches->setCurrentRow(index - 1);
-
-		std::lock_guard<std::mutex> lock(switcher->m);
-
-		iter_swap(switcher->windowSwitches.begin() + index,
-			  switcher->windowSwitches.begin() + index - 1);
-	}
-}
-
-void SceneSwitcher::on_down_clicked()
-{
-	int index = ui->switches->currentRow();
-	if (index != -1 && index != ui->switches->count() - 1) {
-		ui->switches->insertItem(index + 1,
-					 ui->switches->takeItem(index));
-		ui->switches->setCurrentRow(index + 1);
-
-		std::lock_guard<std::mutex> lock(switcher->m);
-
-		iter_swap(switcher->windowSwitches.begin() + index,
-			  switcher->windowSwitches.begin() + index + 1);
-	}
-}
-
-void SceneSwitcher::on_add_clicked()
-{
-	QString sceneName = ui->scenes->currentText();
-	QString windowName = ui->windows->currentText();
-	QString transitionName = ui->transitions->currentText();
-	bool fullscreen = ui->fullscreenCheckBox->isChecked();
-	bool maximized = ui->maximizedCheckBox->isChecked();
-	bool focus = ui->focusCheckBox->isChecked();
-
-	if (windowName.isEmpty() || sceneName.isEmpty())
+	QListWidgetItem *item = ui->windowSwitches->currentItem();
+	if (!item) {
 		return;
-
-	OBSWeakSource source = GetWeakSourceByQString(sceneName);
-	OBSWeakSource transition = GetWeakTransitionByQString(transitionName);
-	QVariant v = QVariant::fromValue(windowName);
-
-	QString text = MakeWindowSwitchName(sceneName, windowName,
-					    transitionName, fullscreen,
-					    maximized, focus);
-
-	int idx = FindByData(windowName);
-
-	if (idx == -1) {
-		std::lock_guard<std::mutex> lock(switcher->m);
-		switcher->windowSwitches.emplace_back(
-			source, windowName.toUtf8().constData(), transition,
-			fullscreen, maximized, focus);
-
-		QListWidgetItem *item = new QListWidgetItem(text, ui->switches);
-		item->setData(Qt::UserRole, v);
-	} else {
-		QListWidgetItem *item = ui->switches->item(idx);
-		item->setText(text);
-
-		std::string window = windowName.toUtf8().constData();
-
-		{
-			std::lock_guard<std::mutex> lock(switcher->m);
-			for (auto &s : switcher->windowSwitches) {
-				if (s.window == window) {
-					s.scene = source;
-					s.transition = transition;
-					s.fullscreen = fullscreen;
-					s.maximized = maximized;
-					s.focus = focus;
-					break;
-				}
-			}
-		}
 	}
-}
-
-void SceneSwitcher::on_remove_clicked()
-{
-	QListWidgetItem *item = ui->switches->currentItem();
-	if (!item)
-		return;
-
-	std::string window =
-		item->data(Qt::UserRole).toString().toUtf8().constData();
 
 	{
 		std::lock_guard<std::mutex> lock(switcher->m);
+		int idx = ui->windowSwitches->currentRow();
 		auto &switches = switcher->windowSwitches;
-
-		for (auto it = switches.begin(); it != switches.end(); ++it) {
-			auto &s = *it;
-
-			if (s.window == window) {
-				switches.erase(it);
-				break;
-			}
-		}
+		switches.erase(switches.begin() + idx);
 	}
 
 	delete item;
 }
 
-void SceneSwitcher::on_ignoreWindowsAdd_clicked()
+void AdvSceneSwitcher::on_windowUp_clicked()
+{
+	int index = ui->windowSwitches->currentRow();
+	if (!listMoveUp(ui->windowSwitches)) {
+		return;
+	}
+
+	WindowSwitchWidget *s1 =
+		(WindowSwitchWidget *)ui->windowSwitches->itemWidget(
+			ui->windowSwitches->item(index));
+	WindowSwitchWidget *s2 =
+		(WindowSwitchWidget *)ui->windowSwitches->itemWidget(
+			ui->windowSwitches->item(index - 1));
+	WindowSwitchWidget::swapSwitchData(s1, s2);
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+
+	std::swap(switcher->windowSwitches[index],
+		  switcher->windowSwitches[index - 1]);
+}
+
+void AdvSceneSwitcher::on_windowDown_clicked()
+{
+	int index = ui->windowSwitches->currentRow();
+
+	if (!listMoveDown(ui->windowSwitches)) {
+		return;
+	}
+
+	WindowSwitchWidget *s1 =
+		(WindowSwitchWidget *)ui->windowSwitches->itemWidget(
+			ui->windowSwitches->item(index));
+	WindowSwitchWidget *s2 =
+		(WindowSwitchWidget *)ui->windowSwitches->itemWidget(
+			ui->windowSwitches->item(index + 1));
+	WindowSwitchWidget::swapSwitchData(s1, s2);
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+
+	std::swap(switcher->windowSwitches[index],
+		  switcher->windowSwitches[index + 1]);
+}
+
+void AdvSceneSwitcher::on_ignoreWindowsAdd_clicked()
 {
 	QString windowName = ui->ignoreWindowsWindows->currentText();
 
-	if (windowName.isEmpty())
+	if (windowName.isEmpty()) {
 		return;
+	}
 
 	QVariant v = QVariant::fromValue(windowName);
 
@@ -157,13 +101,16 @@ void SceneSwitcher::on_ignoreWindowsAdd_clicked()
 		switcher->ignoreWindowsSwitches.emplace_back(
 			windowName.toUtf8().constData());
 	}
+
+	ui->ignoreWindowHelp->setVisible(false);
 }
 
-void SceneSwitcher::on_ignoreWindowsRemove_clicked()
+void AdvSceneSwitcher::on_ignoreWindowsRemove_clicked()
 {
 	QListWidgetItem *item = ui->ignoreWindows->currentItem();
-	if (!item)
+	if (!item) {
 		return;
+	}
 
 	QString windowName = item->data(Qt::UserRole).toString();
 
@@ -184,25 +131,7 @@ void SceneSwitcher::on_ignoreWindowsRemove_clicked()
 	delete item;
 }
 
-int SceneSwitcher::FindByData(const QString &window)
-{
-	int count = ui->switches->count();
-	int idx = -1;
-
-	for (int i = 0; i < count; i++) {
-		QListWidgetItem *item = ui->switches->item(i);
-		QString itemWindow = item->data(Qt::UserRole).toString();
-
-		if (itemWindow == window) {
-			idx = i;
-			break;
-		}
-	}
-
-	return idx;
-}
-
-int SceneSwitcher::IgnoreWindowsFindByData(const QString &window)
+int AdvSceneSwitcher::IgnoreWindowsFindByData(const QString &window)
 {
 	int count = ui->ignoreWindows->count();
 	int idx = -1;
@@ -220,40 +149,14 @@ int SceneSwitcher::IgnoreWindowsFindByData(const QString &window)
 	return idx;
 }
 
-void SceneSwitcher::on_switches_currentRowChanged(int idx)
+void AdvSceneSwitcher::on_ignoreWindows_currentRowChanged(int idx)
 {
-	if (loading)
+	if (loading) {
 		return;
-	if (idx == -1)
-		return;
-
-	QListWidgetItem *item = ui->switches->item(idx);
-
-	QString window = item->data(Qt::UserRole).toString();
-
-	std::lock_guard<std::mutex> lock(switcher->m);
-	for (auto &s : switcher->windowSwitches) {
-		if (window.compare(s.window.c_str()) == 0) {
-			std::string name = GetWeakSourceName(s.scene);
-			std::string transitionName =
-				GetWeakSourceName(s.transition);
-			ui->scenes->setCurrentText(name.c_str());
-			ui->windows->setCurrentText(window);
-			ui->transitions->setCurrentText(transitionName.c_str());
-			ui->fullscreenCheckBox->setChecked(s.fullscreen);
-			ui->maximizedCheckBox->setChecked(s.maximized);
-			ui->focusCheckBox->setChecked(s.focus);
-			break;
-		}
 	}
-}
-
-void SceneSwitcher::on_ignoreWindows_currentRowChanged(int idx)
-{
-	if (loading)
-		return;
-	if (idx == -1)
+	if (idx == -1) {
 		return;
+	}
 
 	QListWidgetItem *item = ui->ignoreWindows->item(idx);
 
@@ -268,54 +171,100 @@ void SceneSwitcher::on_ignoreWindows_currentRowChanged(int idx)
 	}
 }
 
+void checkWindowTitleSwitchDirect(WindowSwitch &s,
+				  std::string &currentWindowTitle, bool &match,
+				  OBSWeakSource &scene,
+				  OBSWeakSource &transition)
+{
+	bool focus = s.window == currentWindowTitle;
+	bool fullscreen = (!s.fullscreen || isFullscreen(s.window));
+	bool max = (!s.maximized || isMaximized(s.window));
+
+	if (focus && fullscreen && max) {
+		match = true;
+		scene = s.getScene();
+		transition = s.transition;
+	}
+}
+
+void checkWindowTitleSwitchRegex(WindowSwitch &s,
+				 std::string &currentWindowTitle,
+				 std::vector<std::string> windowList,
+				 bool &match, OBSWeakSource &scene,
+				 OBSWeakSource &transition)
+{
+	for (auto &window : windowList) {
+		try {
+			std::regex expr(s.window);
+			if (!std::regex_match(window, expr)) {
+				continue;
+			}
+		} catch (const std::regex_error &) {
+		}
+
+		bool focus = window == currentWindowTitle;
+		bool fullscreen = (!s.fullscreen || isFullscreen(window));
+		bool max = (!s.maximized || isMaximized(window));
+
+		if (focus && fullscreen && max) {
+			match = true;
+			scene = s.getScene();
+			transition = s.transition;
+		}
+	}
+}
+
 void SwitcherData::checkWindowTitleSwitch(bool &match, OBSWeakSource &scene,
 					  OBSWeakSource &transition)
 {
-	std::string title;
-	bool ignored = false;
+	if (WindowSwitch::pause) {
+		return;
+	}
+
+	std::string currentWindowTitle;
+	GetCurrentWindowTitle(currentWindowTitle);
 
 	// Check if current window is ignored
-	GetCurrentWindowTitle(title);
 	for (auto &window : ignoreWindowsSwitches) {
-		// True if ignored switch equals current window
-		bool equals = (title == window);
-		// True if ignored switch matches current window
-		bool matches = QString::fromStdString(title).contains(
-			QRegularExpression(QString::fromStdString(window)));
+		bool equals = (currentWindowTitle == window);
 
-		if (equals || matches) {
-			ignored = true;
-			title = lastTitle;
+		try {
+			std::regex expr(window);
+			bool matches =
+				std::regex_match(currentWindowTitle, expr);
 
-			break;
+			if (equals || matches) {
+				currentWindowTitle = lastTitle;
+				break;
+			}
+		} catch (const std::regex_error &) {
 		}
 	}
-	lastTitle = title;
 
-	// Check for match
-	for (WindowSceneSwitch &s : windowSwitches) {
-		// True if fullscreen is disabled OR current window is fullscreen
-		bool fullscreen = (!s.fullscreen || isFullscreen(s.window));
-		// True if maximized is disabled OR current window is maximized
-		bool max = (!s.maximized || isMaximized(s.window));
-		// True if focus is disabled OR switch is focused
-		bool focus = (!s.focus || isFocused(s.window));
-		// True if current window is ignored AND switch equals OR matches last window
-		bool ignore =
-			(ignored &&
-			 (title == s.window ||
-			  QString::fromStdString(title).contains(
-				  QRegularExpression(
-					  QString::fromStdString(s.window)))));
+	lastTitle = currentWindowTitle;
 
-		if (isRunning(s.window) &&
-		    (fullscreen && (max && (focus || ignore)))) {
-			match = true;
-			scene = s.scene;
-			transition = s.transition;
+	std::vector<std::string> windowList;
+	GetWindowList(windowList);
 
-			if (verbose)
+	for (WindowSwitch &s : windowSwitches) {
+		if (!s.initialized()) {
+			continue;
+		}
+
+		if (std::find(windowList.begin(), windowList.end(), s.window) !=
+		    windowList.end()) {
+			checkWindowTitleSwitchDirect(s, currentWindowTitle,
+						     match, scene, transition);
+		} else {
+			checkWindowTitleSwitchRegex(s, currentWindowTitle,
+						    windowList, match, scene,
+						    transition);
+		}
+
+		if (match) {
+			if (verbose) {
 				s.logMatch();
+			}
 			break;
 		}
 	}
@@ -324,29 +273,12 @@ void SwitcherData::checkWindowTitleSwitch(bool &match, OBSWeakSource &scene,
 void SwitcherData::saveWindowTitleSwitches(obs_data_t *obj)
 {
 	obs_data_array_t *windowTitleArray = obs_data_array_create();
-	for (WindowSceneSwitch &s : switcher->windowSwitches) {
+	for (WindowSwitch &s : switcher->windowSwitches) {
 		obs_data_t *array_obj = obs_data_create();
 
-		obs_source_t *source = obs_weak_source_get_source(s.scene);
-		obs_source_t *transition =
-			obs_weak_source_get_source(s.transition);
-		if (source && transition) {
-			const char *sceneName = obs_source_get_name(source);
-			const char *transitionName =
-				obs_source_get_name(transition);
-			obs_data_set_string(array_obj, "scene", sceneName);
-			obs_data_set_string(array_obj, "transition",
-					    transitionName);
-			obs_data_set_string(array_obj, "window_title",
-					    s.window.c_str());
-			obs_data_set_bool(array_obj, "fullscreen",
-					  s.fullscreen);
-			obs_data_set_bool(array_obj, "maximized", s.maximized);
-			obs_data_set_bool(array_obj, "focus", s.focus);
-			obs_data_array_push_back(windowTitleArray, array_obj);
-			obs_source_release(source);
-			obs_source_release(transition);
-		}
+		s.save(array_obj);
+		obs_data_array_push_back(windowTitleArray, array_obj);
+
 		obs_data_release(array_obj);
 	}
 	obs_data_set_array(obj, "switches", windowTitleArray);
@@ -375,26 +307,8 @@ void SwitcherData::loadWindowTitleSwitches(obs_data_t *obj)
 		obs_data_t *array_obj =
 			obs_data_array_item(windowTitleArray, i);
 
-		const char *scene = obs_data_get_string(array_obj, "scene");
-		const char *transition =
-			obs_data_get_string(array_obj, "transition");
-		const char *window =
-			obs_data_get_string(array_obj, "window_title");
-		bool fullscreen = obs_data_get_bool(array_obj, "fullscreen");
-#if __APPLE__
-		// TODO:
-		// not implemented on MacOS as I cannot test it
-		bool maximized = false;
-#else
-		bool maximized = obs_data_get_bool(array_obj, "maximized");
-#endif
-		bool focus = obs_data_get_bool(array_obj, "focus") ||
-			     !obs_data_has_user_value(array_obj, "focus");
-
-		switcher->windowSwitches.emplace_back(
-			GetWeakSourceByName(scene), window,
-			GetWeakTransitionByName(transition), fullscreen,
-			maximized, focus);
+		switcher->windowSwitches.emplace_back();
+		windowSwitches.back().load(array_obj);
 
 		obs_data_release(array_obj);
 	}
@@ -420,26 +334,26 @@ void SwitcherData::loadWindowTitleSwitches(obs_data_t *obj)
 	obs_data_array_release(ignoreWindowsArray);
 }
 
-void SceneSwitcher::setupTitleTab()
+void AdvSceneSwitcher::setupTitleTab()
 {
-	populateSceneSelection(ui->scenes, false);
-	populateTransitionSelection(ui->transitions);
-	populateWindowSelection(ui->windows);
-	populateWindowSelection(ui->ignoreWindowsWindows);
-
 	for (auto &s : switcher->windowSwitches) {
-		std::string sceneName = GetWeakSourceName(s.scene);
-		std::string transitionName = GetWeakSourceName(s.transition);
-		QString text = MakeWindowSwitchName(sceneName.c_str(),
-						    s.window.c_str(),
-						    transitionName.c_str(),
-						    s.fullscreen, s.maximized,
-						    s.focus);
-
-		QListWidgetItem *item = new QListWidgetItem(text, ui->switches);
-		item->setData(Qt::UserRole, s.window.c_str());
+		QListWidgetItem *item;
+		item = new QListWidgetItem(ui->windowSwitches);
+		ui->windowSwitches->addItem(item);
+		WindowSwitchWidget *sw = new WindowSwitchWidget(this, &s);
+		item->setSizeHint(sw->minimumSizeHint());
+		ui->windowSwitches->setItemWidget(item, sw);
 	}
 
+	if (switcher->windowSwitches.size() == 0) {
+		addPulse = PulseWidget(ui->windowAdd, QColor(Qt::green));
+		ui->windowHelp->setVisible(true);
+	} else {
+		ui->windowHelp->setVisible(false);
+	}
+
+	populateWindowSelection(ui->ignoreWindowsWindows);
+
 	for (auto &window : switcher->ignoreWindowsSwitches) {
 		QString text = QString::fromStdString(window);
 
@@ -448,35 +362,189 @@ void SceneSwitcher::setupTitleTab()
 		item->setData(Qt::UserRole, text);
 	}
 
+	if (switcher->ignoreWindowsSwitches.size() == 0) {
+		ui->ignoreWindowHelp->setVisible(true);
+	} else {
+		ui->ignoreWindowHelp->setVisible(false);
+	}
+}
+
+void WindowSwitch::save(obs_data_t *obj)
+{
+	SceneSwitcherEntry::save(obj);
+
+	obs_data_set_string(obj, "windowTitle", window.c_str());
+	obs_data_set_bool(obj, "fullscreen", fullscreen);
+	obs_data_set_bool(obj, "maximized", maximized);
+	obs_data_set_bool(obj, "focus", focus);
+}
+
+// To be removed in future version
+bool loadOldWindow(obs_data_t *obj, WindowSwitch *s)
+{
+	if (!s) {
+		return false;
+	}
+
+	const char *scene = obs_data_get_string(obj, "scene");
+
+	if (strcmp(scene, "") == 0) {
+		return false;
+	}
+
+	s->scene = GetWeakSourceByName(scene);
+
+	const char *transition = obs_data_get_string(obj, "transition");
+	s->transition = GetWeakTransitionByName(transition);
+
+	s->window = obs_data_get_string(obj, "window_title");
+	s->fullscreen = obs_data_get_bool(obj, "fullscreen");
 #if __APPLE__
 	// TODO:
 	// not implemented on MacOS as I cannot test it
-	ui->maximizedCheckBox->setDisabled(true);
-	ui->maximizedCheckBox->setVisible(false);
+	s->maximized = false;
+#else
+	s->maximized = obs_data_get_bool(obj, "maximized");
 #endif
+	s->focus = obs_data_get_bool(obj, "focus") ||
+		   !obs_data_has_user_value(obj, "focus");
+	s->usePreviousScene = strcmp(scene, previous_scene_name) == 0;
+
+	return true;
 }
 
-static inline QString MakeWindowSwitchName(const QString &scene,
-					   const QString &value,
-					   const QString &transition,
-					   bool fullscreen, bool maximized,
-					   bool focus)
+void WindowSwitch::load(obs_data_t *obj)
 {
-	QString name = QStringLiteral("[") + scene + QStringLiteral(", ") +
-		       transition + QStringLiteral("]: ") + value;
-
-	if (fullscreen || maximized || focus) {
-		name += QStringLiteral(" (only if");
-
-		if (fullscreen)
-			name += QStringLiteral(" fullscreen ");
-		if (maximized)
-			name += QStringLiteral(" maximized ");
-		if (focus)
-			name += QStringLiteral(" focused");
-
-		name += QStringLiteral(")");
+	if (loadOldWindow(obj, this)) {
+		return;
 	}
 
-	return name;
+	SceneSwitcherEntry::load(obj);
+
+	window = obs_data_get_string(obj, "windowTitle");
+	fullscreen = obs_data_get_bool(obj, "fullscreen");
+#if __APPLE__
+	// TODO:
+	// not implemented on MacOS as I cannot test it
+	maximized = false;
+#else
+	maximized = obs_data_get_bool(obj, "maximized");
+#endif
+	focus = obs_data_get_bool(obj, "focus") ||
+		!obs_data_has_user_value(obj, "focus");
+}
+
+WindowSwitchWidget::WindowSwitchWidget(QWidget *parent, WindowSwitch *s)
+	: SwitchWidget(parent, s, true, true)
+{
+	windows = new QComboBox();
+	fullscreen = new QCheckBox(
+		obs_module_text("AdvSceneSwitcher.windowTitleTab.fullscreen"));
+	maximized = new QCheckBox(
+		obs_module_text("AdvSceneSwitcher.windowTitleTab.maximized"));
+	focused = new QCheckBox(
+		obs_module_text("AdvSceneSwitcher.windowTitleTab.focused"));
+
+	QWidget::connect(windows, SIGNAL(currentTextChanged(const QString &)),
+			 this, SLOT(WindowChanged(const QString &)));
+	QWidget::connect(fullscreen, SIGNAL(stateChanged(int)), this,
+			 SLOT(FullscreenChanged(int)));
+	QWidget::connect(maximized, SIGNAL(stateChanged(int)), this,
+			 SLOT(MaximizedChanged(int)));
+	QWidget::connect(focused, SIGNAL(stateChanged(int)), this,
+			 SLOT(FocusChanged(int)));
+
+	AdvSceneSwitcher::populateWindowSelection(windows);
+
+	windows->setEditable(true);
+	windows->setMaxVisibleItems(20);
+#if __APPLE__
+	// TODO:
+	// not implemented on MacOS as I cannot test it
+	maximized->setDisabled(true);
+	maximized->setVisible(false);
+#endif
+
+	if (s) {
+		windows->setCurrentText(s->window.c_str());
+		fullscreen->setChecked(s->fullscreen);
+		maximized->setChecked(s->maximized);
+		focused->setChecked(s->focus);
+	}
+
+	QHBoxLayout *mainLayout = new QHBoxLayout;
+	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
+		{"{{windows}}", windows},
+		{"{{scenes}}", scenes},
+		{"{{transitions}}", transitions},
+		{"{{fullscreen}}", fullscreen},
+		{"{{maximized}}", maximized},
+		{"{{focused}}", focused}};
+	placeWidgets(obs_module_text("AdvSceneSwitcher.windowTitleTab.entry"),
+		     mainLayout, widgetPlaceholders);
+	setLayout(mainLayout);
+
+	switchData = s;
+
+	loading = false;
+}
+
+WindowSwitch *WindowSwitchWidget::getSwitchData()
+{
+	return switchData;
+}
+
+void WindowSwitchWidget::setSwitchData(WindowSwitch *s)
+{
+	switchData = s;
+}
+
+void WindowSwitchWidget::swapSwitchData(WindowSwitchWidget *s1,
+					WindowSwitchWidget *s2)
+{
+	SwitchWidget::swapSwitchData(s1, s2);
+
+	WindowSwitch *t = s1->getSwitchData();
+	s1->setSwitchData(s2->getSwitchData());
+	s2->setSwitchData(t);
+}
+
+void WindowSwitchWidget::WindowChanged(const QString &text)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->window = text.toStdString();
+}
+
+void WindowSwitchWidget::FullscreenChanged(int state)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->fullscreen = state;
+}
+
+void WindowSwitchWidget::MaximizedChanged(int state)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->maximized = state;
+}
+
+void WindowSwitchWidget::FocusChanged(int state)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->focus = state;
 }

src/switcher-data-structs.cpp

@@ -4,9 +4,10 @@
 void SwitcherData::Prune()
 {
 	for (size_t i = 0; i < windowSwitches.size(); i++) {
-		WindowSceneSwitch &s = windowSwitches[i];
-		if (!s.valid())
+		WindowSwitch &s = windowSwitches[i];
+		if (!s.valid()) {
 			windowSwitches.erase(windowSwitches.begin() + i--);
+		}
 	}
 
 	if (nonMatchingScene && !WeakSourceValid(nonMatchingScene)) {
@@ -16,66 +17,69 @@ void SwitcherData::Prune()
 
 	for (size_t i = 0; i < randomSwitches.size(); i++) {
 		RandomSwitch &s = randomSwitches[i];
-		if (!s.valid())
+		if (!s.valid()) {
 			randomSwitches.erase(randomSwitches.begin() + i--);
+		}
 	}
 
 	for (size_t i = 0; i < screenRegionSwitches.size(); i++) {
 		ScreenRegionSwitch &s = screenRegionSwitches[i];
-		if (!s.valid())
+		if (!s.valid()) {
 			screenRegionSwitches.erase(
 				screenRegionSwitches.begin() + i--);
+		}
 	}
 
-	for (size_t i = 0; i < pauseScenesSwitches.size(); i++) {
-		OBSWeakSource &scene = pauseScenesSwitches[i];
-		if (!WeakSourceValid(scene))
-			pauseScenesSwitches.erase(pauseScenesSwitches.begin() +
-						  i--);
+	for (size_t i = 0; i < pauseEntries.size(); i++) {
+		PauseEntry &s = pauseEntries[i];
+		if (!s.valid()) {
+			pauseEntries.erase(pauseEntries.begin() + i--);
+		}
 	}
 
 	for (size_t i = 0; i < sceneSequenceSwitches.size(); i++) {
 		SceneSequenceSwitch &s = sceneSequenceSwitches[i];
-		if (!s.valid())
+		if (!s.valid()) {
 			sceneSequenceSwitches.erase(
 				sceneSequenceSwitches.begin() + i--);
-	}
-
-	if (!WeakSourceValid(autoStopScene)) {
-		autoStopScene = nullptr;
-		autoStopEnable = false;
+		}
 	}
 
 	for (size_t i = 0; i < sceneTransitions.size(); i++) {
 		SceneTransition &s = sceneTransitions[i];
-		if (!s.valid())
+		if (!s.valid()) {
 			sceneTransitions.erase(sceneTransitions.begin() + i--);
+		}
 	}
 
 	for (size_t i = 0; i < defaultSceneTransitions.size(); i++) {
 		DefaultSceneTransition &s = defaultSceneTransitions[i];
-		if (!s.valid())
+		if (!s.valid()) {
 			defaultSceneTransitions.erase(
 				defaultSceneTransitions.begin() + i--);
+		}
 	}
 
 	for (size_t i = 0; i < executableSwitches.size(); i++) {
-		ExecutableSceneSwitch &s = executableSwitches[i];
-		if (!s.valid())
+		ExecutableSwitch &s = executableSwitches[i];
+		if (!s.valid()) {
 			executableSwitches.erase(executableSwitches.begin() +
 						 i--);
+		}
 	}
 
 	for (size_t i = 0; i < fileSwitches.size(); i++) {
 		FileSwitch &s = fileSwitches[i];
-		if (!s.valid())
+		if (!s.valid()) {
 			fileSwitches.erase(fileSwitches.begin() + i--);
+		}
 	}
 
 	for (size_t i = 0; i < timeSwitches.size(); i++) {
 		TimeSwitch &s = timeSwitches[i];
-		if (!s.valid())
+		if (!s.valid()) {
 			timeSwitches.erase(timeSwitches.begin() + i--);
+		}
 	}
 
 	if (!idleData.valid()) {
@@ -84,13 +88,33 @@ void SwitcherData::Prune()
 
 	for (size_t i = 0; i < mediaSwitches.size(); i++) {
 		MediaSwitch &s = mediaSwitches[i];
-		if (!s.valid())
+		if (!s.valid()) {
 			mediaSwitches.erase(mediaSwitches.begin() + i--);
+		}
 	}
 
 	for (size_t i = 0; i < audioSwitches.size(); i++) {
 		AudioSwitch &s = audioSwitches[i];
-		if (!s.valid())
+		if (!s.valid()) {
 			audioSwitches.erase(audioSwitches.begin() + i--);
+		}
+	}
+
+	for (auto &sg : sceneGroups) {
+		for (size_t i = 0; i < sg.scenes.size(); i++)
+			if (!WeakSourceValid(sg.scenes[i])) {
+				sg.scenes.erase(sg.scenes.begin() + i--);
+			}
 	}
 }
+
+bool SwitcherData::versionChanged(obs_data_t *obj, std::string currentVersion)
+{
+	std::string previousVersion = obs_data_get_string(obj, "version");
+	return previousVersion != currentVersion;
+}
+
+void SwitcherData::saveVersion(obs_data_t *obj, std::string currentVersion)
+{
+	obs_data_set_string(obj, "version", currentVersion.c_str());
+}

src/volume-control.cpp

@@ -82,7 +82,10 @@ VolControl::VolControl(OBSSource source_, bool vertical)
 	nameLabel = new QLabel();
 	volLabel = new QLabel();
 
-	QString sourceName = obs_source_get_name(source);
+	QString sourceName = "";
+	if (source) {
+		obs_source_get_name(source);
+	}
 	setObjectName(sourceName);
 
 	QVBoxLayout *mainLayout = new QVBoxLayout;

src/win/advanced-scene-switcher-win.cpp

@@ -3,17 +3,21 @@
 #include "../headers/advanced-scene-switcher.hpp"
 #include <TlHelp32.h>
 #include <Psapi.h>
+#include <locale>
+#include <codecvt>
+#include <string>
 
-using namespace std;
+#define MAX_SEARCH 1000
 
-static bool GetWindowTitle(HWND window, string &title)
+static bool GetWindowTitle(HWND window, std::string &title)
 {
 	size_t len = (size_t)GetWindowTextLengthW(window);
-	wstring wtitle;
+	std::wstring wtitle;
 
 	wtitle.resize(len);
-	if (!GetWindowTextW(window, &wtitle[0], (int)len + 1))
+	if (!GetWindowTextW(window, &wtitle[0], (int)len + 1)) {
 		return false;
+	}
 
 	len = os_wcs_to_utf8(wtitle.c_str(), 0, nullptr, 0);
 	title.resize(len);
@@ -26,59 +30,86 @@ static bool WindowValid(HWND window)
 	LONG_PTR styles;
 	DWORD id;
 
-	if (!IsWindowVisible(window))
+	if (!IsWindowVisible(window)) {
 		return false;
+	}
 	GetWindowThreadProcessId(window, &id);
-	if (id == GetCurrentProcessId())
+	if (id == GetCurrentProcessId()) {
 		return false;
+	}
 
 	styles = GetWindowLongPtr(window, GWL_STYLE);
 
-	if (styles & WS_CHILD)
+	if (styles & WS_CHILD) {
 		return false;
+	}
 
 	return true;
 }
 
-void GetWindowList(vector<string> &windows)
+BOOL CALLBACK GetTitleCB(HWND hwnd, LPARAM lParam)
 {
-	windows.resize(0);
+	if (!WindowValid(hwnd)) {
+		return TRUE;
+	}
 
-	HWND window = GetWindow(GetDesktopWindow(), GW_CHILD);
+	std::string title;
+	GetWindowTitle(hwnd, title);
+	if (title.empty()) {
+		return TRUE;
+	}
 
-	while (window) {
-		string title;
-		if (WindowValid(window) && GetWindowTitle(window, title))
-			windows.emplace_back(title);
-		window = GetNextWindow(window, GW_HWNDNEXT);
+	std::vector<std::string> &titles =
+		*reinterpret_cast<std::vector<std::string> *>(lParam);
+	titles.push_back(title);
+
+	return TRUE;
+}
+
+VOID EnumWindowsWithMetro(__in WNDENUMPROC lpEnumFunc, __in LPARAM lParam)
+{
+	HWND childWindow = NULL;
+	int i = 0;
+
+	while (i < MAX_SEARCH &&
+	       (childWindow = FindWindowEx(NULL, childWindow, NULL, NULL))) {
+		if (!lpEnumFunc(childWindow, lParam)) {
+			return;
+		}
+		i++;
 	}
 }
 
-// Overloaded
+void GetWindowList(std::vector<std::string> &windows)
+{
+	windows.resize(0);
+	EnumWindowsWithMetro(GetTitleCB, reinterpret_cast<LPARAM>(&windows));
+}
+
 void GetWindowList(QStringList &windows)
 {
 	windows.clear();
 
-	HWND window = GetWindow(GetDesktopWindow(), GW_CHILD);
-
-	while (window) {
-		string title;
-		if (WindowValid(window) && GetWindowTitle(window, title))
-			windows << QString::fromStdString(title);
-		window = GetNextWindow(window, GW_HWNDNEXT);
+	std::vector<std::string> w;
+	GetWindowList(w);
+	for (auto window : w) {
+		windows << QString::fromStdString(window);
 	}
+
+	// Add entry for OBS Studio itself, see GetCurrentWindowTitle
+	windows << QString("OBS");
 }
 
-void GetCurrentWindowTitle(string &title)
+void GetCurrentWindowTitle(std::string &title)
 {
 	HWND window = GetForegroundWindow();
 	DWORD pid;
 	DWORD thid;
 	thid = GetWindowThreadProcessId(window, &pid);
-	/*GetWindowText will freeze if the control it is reading was created in another thread.
-	It does not directly read the control.Instead,
-	it waits for the thread that created the control to process a WM_GETTEXT message.
-	So if that thread is frozen in a WaitFor... call you have a deadlock.*/
+	// GetWindowText will freeze if the control it is reading was created in another thread.
+	// It does not directly read the control.
+	// Instead it waits for the thread that created the control to process a WM_GETTEXT message.
+	// So if that thread is frozen in a WaitFor... call you have a deadlock.
 	if (GetCurrentProcessId() == pid) {
 		title = "OBS";
 		return;
@@ -97,21 +128,26 @@ std::pair<int, int> getCursorPos()
 	return pos;
 }
 
+HWND getHWNDfromTitle(std::string title)
+{
+	HWND hwnd = NULL;
+
+	std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
+	std::wstring wTitle = converter.from_bytes(title);
+
+	hwnd = FindWindowEx(NULL, NULL, NULL, wTitle.c_str());
+	return hwnd;
+}
+
 bool isMaximized(std::string &title)
 {
 	RECT appBounds;
 	MONITORINFO monitorInfo = {0};
+	HWND hwnd = NULL;
 
-	HWND hwnd = GetWindow(GetDesktopWindow(), GW_CHILD);
-	while (hwnd) {
-		string wtitle;
-		if (WindowValid(hwnd) && GetWindowTitle(hwnd, wtitle) &&
-		    (wtitle == title ||
-		     QString::fromStdString(wtitle).contains(QRegularExpression(
-			     QString::fromStdString(title)))))
-			break;
-
-		hwnd = GetNextWindow(hwnd, GW_HWNDNEXT);
+	hwnd = getHWNDfromTitle(title);
+	if (!hwnd) {
+		return false;
 	}
 
 	monitorInfo.cbSize = sizeof(MONITORINFO);
@@ -138,16 +174,11 @@ bool isFullscreen(std::string &title)
 	RECT appBounds;
 	MONITORINFO monitorInfo = {0};
 
-	HWND hwnd = GetWindow(GetDesktopWindow(), GW_CHILD);
-	while (hwnd) {
-		string wtitle;
-		if (WindowValid(hwnd) && GetWindowTitle(hwnd, wtitle) &&
-		    (wtitle == title ||
-		     QString::fromStdString(wtitle).contains(QRegularExpression(
-			     QString::fromStdString(title)))))
-			break;
+	HWND hwnd = NULL;
+	hwnd = getHWNDfromTitle(title);
 
-		hwnd = GetNextWindow(hwnd, GW_HWNDNEXT);
+	if (!hwnd) {
+		return false;
 	}
 
 	monitorInfo.cbSize = sizeof(MONITORINFO);
@@ -174,8 +205,9 @@ void GetProcessList(QStringList &processes)
 	PROCESSENTRY32 procEntry;
 
 	procSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
-	if (procSnapshot == INVALID_HANDLE_VALUE)
+	if (procSnapshot == INVALID_HANDLE_VALUE) {
 		return;
+	}
 
 	procEntry.dwSize = sizeof(PROCESSENTRY32);
 
@@ -186,12 +218,15 @@ void GetProcessList(QStringList &processes)
 
 	do {
 		QString tempexe = QString::fromWCharArray(procEntry.szExeFile);
-		if (tempexe == "System")
+		if (tempexe == "System") {
 			continue;
-		if (tempexe == "[System Process]")
+		}
+		if (tempexe == "[System Process]") {
 			continue;
-		if (processes.contains(tempexe))
+		}
+		if (processes.contains(tempexe)) {
 			continue;
+		}
 		processes.append(tempexe);
 	} while (Process32Next(procSnapshot, &procEntry));
 
@@ -208,8 +243,9 @@ bool isInFocus(const QString &executable)
 
 	HANDLE process = OpenProcess(
 		PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, processId);
-	if (process == NULL)
+	if (process == NULL) {
 		return false;
+	}
 
 	WCHAR executablePath[600];
 	GetModuleFileNameEx(process, 0, executablePath, 600);
@@ -231,8 +267,9 @@ int getLastInputTime()
 {
 	LASTINPUTINFO lastInputInfo;
 	lastInputInfo.cbSize = sizeof(LASTINPUTINFO);
-	if (GetLastInputInfo(&lastInputInfo))
+	if (GetLastInputInfo(&lastInputInfo)) {
 		return lastInputInfo.dwTime;
+	}
 	return 0;
 }