Expand date condition functionality

The date condition now supports the condition types "after", "before"
and specifying a time range.

.github/workflows/build.yml

@@ -160,6 +160,7 @@ jobs:
            libxcb-xinerama0-dev \
            libxcomposite-dev \
            libxinerama-dev \
+           libxtst-dev \
            libmbedtls-dev \
            pkg-config \
            python3-dev \
@@ -200,7 +201,7 @@ jobs:
       QT_VERSION: 5.10.1
       CMAKE_GENERATOR: "Visual Studio 16 2019"
       CMAKE_SYSTEM_VERSION: "10.0.18363.657"
-      WINDOWS_DEPS_VERSION: '2017'
+      WINDOWS_DEPS_VERSION: '2019'
     steps:
       - name: Add msbuild to PATH
         uses: microsoft/setup-msbuild@v1.0.2

BUILDING.md

@@ -0,0 +1,131 @@
+# Compiling the plugin
+
+You have the option to ...
+- either add the plugin to the OBS source tree directly and build the plugin while building OBS itself. (**in tree**)
+- or you can move the sources of this plugin outside of the OBS source tree and build it separately from OBS. (**out of tree**)
+
+As both methods require you to have a working [OBS Studio development environment](https://obsproject.com/wiki/install-instructions), [Qt](https://download.qt.io/official_releases/qt/5.15/5.15.2/) and [CMake](https://cmake.org/download/) it is recommended to build the plugin in tree as it is easier to set up and will enable straightforward debugging.
+
+Note that your Qt install must include the QtConcurrent module.
+
+## 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/
+git clone --recursive https://github.com/WarmUpTill/SceneSwitcher.git
+```
+
+Then modify the obs-studio/UI/frontend-plugins/CMakeLists.txt file and add an entry for the scene switcher:
+add_subdirectory(SceneSwitcher)
+
+## Compiling out of tree
+### Prerequisites
+You'll need [Qt](https://download.qt.io/official_releases/qt/5.15/5.15.2/), [CMake](https://cmake.org/download/) and a working [OBS Studio development environment](https://obsproject.com/wiki/install-instructions) installed on your computer.
+Once you've set this up, do the following:
+```
+git clone --recursive https://github.com/WarmUpTill/SceneSwitcher.git
+cd SceneSwitcher
+mkdir build && cd build
+```
+
+### Windows
+In cmake-gui, you'll have to set these CMake variables :
+- **BUILD_OUT_OF_TREE** (bool) : true
+
+- **LIBOBS_LIB** (filepath) : location of the obs.lib file
+- **LIBOBS_INCLUDE_DIR** (path) : location of the libobs subfolder in the source
+code of OBS Studio, located at [source_directory]/libobs/.
+
+- **LIBOBS_FRONTEND_API_LIB** (filepath) : location of the obs-frontend-api.lib file
+(usually in the same place as LIBOBS_LIB)
+- **LIBOBS_FRONTEND_INCLUDE_DIR** (path) : location of the obs-frontend-api
+subfolder in the source code of OBS Studio, located at [source_directory]/UI/obs-frontend-api.
+
+- **CURL_LIB** (filepath) : location of the libcurl.lib file
+(part of the dependencies2019/win64/bin folder used to build OBS)
+- **CURL_INCLUDE_DIR** (path) : location of the curl
+subfolder in OBS dependencies folder: ".../dependencies2019/win64/include/"
+
+
+Assuming that you set up Qt via QT installer:
+- **Qt5Core_DIR** (path) : C:/Qt/5.15.2/msvc2019_64/lib/cmake/Qt5Core
+- **Qt5Gui_DIR** (path): C:/Qt/5.15.2/msvc2019_64/lib/cmake/Qt5Gui
+- **Qt5Widgets_DIR** (path) : C:/Qt/5.15.2/msvc2019_64/lib/cmake/Qt5Widgets
+
+Just keep hitting configure until all the vars are filled out. Then hit generate.
+
+### Linux
+Most versions of Linux you can use cmake-gui or the command line.
+
+**For the command line:**  
+```
+# [...] are placeholders
+cmake -DBUILD_OUT_OF_TREE=1 \
+-DLIBOBS_INCLUDE_DIR=[...]/obs-studio/libobs/ \
+-DLIBOBS_LIB=[...]/libobs.so \
+-DLIBOBS_FRONTEND_INCLUDE_DIR=[...]/obs-studio/UI/obs-frontend-api/ \
+-DLIBOBS_FRONTEND_API_LIB=[...]/libobs-frontend-api.so \
+-DCMAKE_INSTALL_PREFIX=/usr ..
+make -j4
+sudo make install
+```
+
+For cmake-gui you'll have to set the following variables:
+- **BUILD_OUT_OF_TREE** (bool) : true
+- **LIBOBS_INCLUDE_DIR** (path) : location of the libobs subfolder in the source
+code of OBS Studio, located at [source_directory]/libobs/.
+- **LIBOBS_LIB** (filepath) : location of the libobs.so file (usually CMake finds
+this, but if not it'll usually be in /usr/lib/libobs.so)
+- **LIBOBS_FRONTEND_API_LIB** (filepath) : location of the libobs-frontend-api.so
+file (usually in the same place as LIBOBS_LIB)
+- **LIBOBS_FRONTEND_INCLUDE_DIR** (path) : location of the obs-frontend-api
+subfolder in the source code of OBS Studio, located at
+[source_directory]/UI/obs-frontend-api.
+
+Assuming that you installed Qt via your system package manager, it should be 
+found automatically. If not, then usually you'll find it in something like:
+- **Qt5Core_DIR** (path) : /usr/lib64/cmake/Qt5Core
+- **Qt5Gui_DIR** (path): /usr/lib64/cmake/Qt5Gui
+- **Qt5Widgets_DIR** (path) : /usr/lib64/cmake/Qt5Widgets
+
+Just keep hitting configure until all the vars are filled out. Then hit generate.
+
+Then open a terminal in the build folder and type:
+```
+make -j4
+sudo make install
+```
+NOTE: The Linux version of this plugin is dependent on libXScrnSaver, libcurl and libXtst.
+
+### OS X
+In cmake-gui, you'll have to set these CMake variables :
+- **BUILD_OUT_OF_TREE** (bool) : true
+- **LIBOBS_INCLUDE_DIR** (path) : location of the libobs subfolder in the source
+code of OBS Studio, located at [source_directory]/libobs/.
+- **LIBOBS_LIB** (filepath) : location of the libobs.0.dylib file (usually
+in /Applications/OBS.app/Contents/Resources/bin/libobs.0.dylib)
+- **LIBOBS_FRONTEND_API_LIB** (filepath) : location of the libobs-frontend-api.0.dylib
+file (usually in usually in /Applications/OBS.app/Contents/Resources/bin/libobs-frontend-api.0.dylib)
+- **LIBOBS_FRONTEND_INCLUDE_DIR** (path) : location of the obs-frontend-api subfolder
+in the source code of OBS Studio, located at [source_directory]/UI/obs-frontend-api.
+
+Assuming that you installed Qt via the regular Qt App way:
+- **Qt5Core_DIR** (path) : Usually /Applications/Qt/5.10.1/clang_64/lib/cmake/Qt5Core
+- **Qt5Widgets_DIR** (path) : Usually /Applications/Qt/5.10.1/clang_64/lib/cmake/Qt5Widgets
+- **Qt5MacExtras_DIR** (path) : Usually /Applications/Qt/5.10.1/clang_64/lib/cmake/Qt5MacExtras
+
+
+Just keep hitting configure until all the vars are filled out. Then hit generate.
+
+Open xcode (or a terminal, depending on the build type you chose), build and 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/'.
+
+Note that you might have to adjust the library search paths using the install_name_tool if you want the plugin to run on machines other than your build machine:
+```
+install_name_tool -change @rpath/libobs-frontend-api.dylib @executable_path/../Frameworks/libobs-frontend-api.dylib UI/frontend-plugins/SceneSwitcher/advanced-scene-switcher.so
+install_name_tool -change @rpath/libobs.0.dylib @executable_path/../Frameworks/libobs.0.dylib UI/frontend-plugins/SceneSwitcher/advanced-scene-switcher.so
+install_name_tool -change /usr/local/opt/qt5/lib/QtWidgets.framework/Versions/5/QtWidgets @executable_path/../Frameworks/QtWidgets.framework/Versions/5/QtWidgets UI/frontend-plugins/SceneSwitcher/advanced-scene-switcher.so
+install_name_tool -change /usr/local/opt/qt5/lib/QtGui.framework/Versions/5/QtGui @executable_path/../Frameworks/QtGui.framework/Versions/5/QtGui UI/frontend-plugins/SceneSwitcher/advanced-scene-switcher.so
+install_name_tool -change /usr/local/opt/qt5/lib/QtCore.framework/Versions/5/QtCore @executable_path/../Frameworks/QtCore.framework/Versions/5/QtCore UI/frontend-plugins/SceneSwitcher/advanced-scene-switcher.so
+```

CMakeLists.txt

@@ -1,270 +1,347 @@
-cmake_minimum_required(VERSION 3.5)
-
+cmake_minimum_required(VERSION 3.14)
 project(advanced-scene-switcher)
-add_definitions(-DASIO_STANDALONE)
 
-# generate version info
+if(NOT CMAKE_BUILD_TYPE)
+  set(CMAKE_BUILD_TYPE RELWITHDEBINFO)
+endif()
+
+# Compiler settings
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED YES)
+
+if(CMAKE_COMPILER_IS_GNUCC
+   OR CMAKE_COMPILER_IS_GNUCXX
+   OR CMAKE_COMPILER_IS_CLANG)
+  set(CMAKE_CXX_FLAGS
+      "-Wall -Wextra -Wvla -Wno-unused-function -Wno-missing-field-initializers ${CMAKE_CXX_FLAGS} -fno-strict-aliasing"
+  )
+  set(CMAKE_C_FLAGS
+      "-Wall -Wextra -Wvla -Wno-unused-function -Werror-implicit-function-declaration -Wno-missing-braces -Wno-missing-field-initializers ${CMAKE_C_FLAGS} -std=gnu99 -fno-strict-aliasing"
+  )
+
+  option(USE_LIBC++ "Use libc++ instead of libstdc++" ${APPLE})
+  if(USE_LIBC++)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++")
+  endif()
+elseif(MSVC)
+  if(CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
+    string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+  else()
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4")
+  endif()
+
+  # Disable pointless constant condition warnings
+  set(CMAKE_CXX_FLAGS
+      "${CMAKE_CXX_FLAGS} /wd4127 /wd4201 /wd4456 /wd4457 /wd4458 /wd4459 /wd4595"
+  )
+  add_definitions(-DUNICODE -D_UNICODE -D_CRT_SECURE_NO_WARNINGS
+                  -D_CRT_NONSTDC_NO_WARNINGS)
+endif()
+
+# 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)
+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)
+  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()
 
+# Windows installer
 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)
+  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()
 
+# Out of tree specific settings
 if(BUILD_OUT_OF_TREE)
-	set(CMAKE_PREFIX_PATH "${QTDIR}")
-	set(CMAKE_INCLUDE_CURRENT_DIR ON)
-	list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/external")
+  set(CMAKE_PREFIX_PATH "${QTDIR}")
+  set(CMAKE_INCLUDE_CURRENT_DIR ON)
+  list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/external")
+  include(external/FindLibObs.cmake)
+  find_package(LibObs REQUIRED)
+  find_package(Qt5Core REQUIRED)
+  find_package(Qt5Widgets REQUIRED)
+  find_path(LIBOBS_FRONTEND_INCLUDE_DIR HINTS ${LIBOBS_INCLUDE_DIRS})
+  find_file(
+    LIBOBS_FRONTEND_API_LIB
+    NAMES libobs-frontend-api.*
+    HINTS ${LIBOBS_LIB})
 
-	include(external/FindLibObs.cmake)
-	find_package(LibObs REQUIRED)
-	find_package(Qt5Core REQUIRED)
-	find_package(Qt5Widgets REQUIRED)
-	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} )
+  include_directories("${LIBOBS_INCLUDE_DIRS}" "${LIBOBS_FRONTEND_INCLUDE_DIR}"
+                      ${Qt5Core_INCLUDES} ${Qt5Widgets_INCLUDES})
 endif()
 
+# Platform specific settings
 if(APPLE)
-	find_library(COCOA Cocoa)
-	if(BUILD_OUT_OF_TREE)
-		find_package(Qt5MacExtras REQUIRED)
-	endif()
-	include_directories(${COCOA})
+  find_library(COCOA Cocoa)
+  if(BUILD_OUT_OF_TREE)
+    find_package(Qt5MacExtras REQUIRED)
+  endif()
+  include_directories(${COCOA})
 endif()
 
+find_package(Libcurl REQUIRED)
+include_directories("${LIBCURL_INCLUDE_DIRS}")
 
 if(UNIX AND NOT APPLE)
-	find_package(X11 REQUIRED)
-	link_libraries(${X11_LIBRARIES})
-	include_directories(${X11_INCLUDE_DIR})
+  find_package(X11 REQUIRED COMPONENTS Xtst Xss)
+  link_libraries(${X11_LIBRARIES})
+  include_directories("${X11_INCLUDE_DIR}" "${X11_Xtst_INCLUDE_PATH}"
+                      "${X11_Xss_INCLUDE_PATH}")
 endif()
 
-include_directories(
-	"${CMAKE_CURRENT_SOURCE_DIR}/deps/asio/asio/include"
-	"${CMAKE_CURRENT_SOURCE_DIR}/deps/websocketpp"
-	)
-
-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/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-network.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-video.hpp
-	src/headers/switch-generic.hpp
-	src/headers/macro-action-edit.hpp
-	src/headers/macro-action-audio.hpp
-	src/headers/macro-action-recording.hpp
-	src/headers/macro-action-replay-buffer.hpp
-	src/headers/macro-action-run.hpp
-	src/headers/macro-action-streaming.hpp
-	src/headers/macro-action-switch-scene.hpp
-	src/headers/macro-action-wait.hpp
-	src/headers/macro-condition-edit.hpp
-	src/headers/macro-condition-audio.hpp
-	src/headers/macro-condition-file.hpp
-	src/headers/macro-condition-idle.hpp
-	src/headers/macro-condition-media.hpp
-	src/headers/macro-condition-plugin-state.hpp
-	src/headers/macro-condition-process.hpp
-	src/headers/macro-condition-recording.hpp
-	src/headers/macro-condition-region.hpp
-	src/headers/macro-condition-scene.hpp
-	src/headers/macro-condition-streaming.hpp
-	src/headers/macro-condition-video.hpp
-	src/headers/macro-condition-window.hpp
-	src/headers/macro.hpp
-	src/headers/curl-helper.hpp
-	src/headers/screenshot-helper.hpp
-	src/headers/name-dialog.hpp
-	src/headers/duration-control.hpp
-	src/headers/section.hpp
-	src/headers/volume-control.hpp
-	src/headers/version.h
-	)
-
-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/switch-network.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-video.cpp
-	src/switch-generic.cpp
-	src/macro-action-edit.cpp
-	src/macro-action-audio.cpp
-	src/macro-action-recording.cpp
-	src/macro-action-replay-buffer.cpp
-	src/macro-action-run.cpp
-	src/macro-action-streaming.cpp
-	src/macro-action-switch-scene.cpp
-	src/macro-action-wait.cpp
-	src/macro-condition-edit.cpp
-	src/macro-condition-audio.cpp
-	src/macro-condition-file.cpp
-	src/macro-condition-idle.cpp
-	src/macro-condition-media.cpp
-	src/macro-condition-plugin-state.cpp
-	src/macro-condition-process.cpp
-	src/macro-condition-recording.cpp
-	src/macro-condition-region.cpp
-	src/macro-condition-scene.cpp
-	src/macro-condition-streaming.cpp
-	src/macro-condition-video.cpp
-	src/macro-condition-window.cpp
-	src/macro.cpp
-	src/macro-tab.cpp
-	src/curl-helper.cpp
-	src/screenshot-helper.cpp
-	src/name-dialog.cpp
-	src/duration-control.cpp
-	src/section.cpp
-	src/volume-control.cpp
-	src/version.cpp
-	)
-
-set(advanced-scene-switcher_UI
-	${advanced-scene-switcher_UI}
-	forms/advanced-scene-switcher.ui
-	)
-
 if(WIN32)
-	add_definitions(-D_WEBSOCKETPP_CPP11_STL_)
-
-	set(advanced-scene-switcher_PLATFORM_SOURCES
-		src/win/advanced-scene-switcher-win.cpp)
+  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})
+  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)
+  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})
+# asio and websocketpp
+add_definitions(-DASIO_STANDALONE)
+include_directories("${CMAKE_CURRENT_SOURCE_DIR}/deps/asio/asio/include"
+                    "${CMAKE_CURRENT_SOURCE_DIR}/deps/websocketpp")
+if(WIN32)
+  add_definitions(-D_WEBSOCKETPP_CPP11_STL_)
+endif()
 
-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}
-	)
+# Setup QT tools
+set(CMAKE_AUTOMOC ON)
+set(CMAKE_AUTOUIC ON)
+set(CMAKE_AUTOUIC_SEARCH_PATHS "${CMAKE_CURRENT_SOURCE_DIR}/forms")
+set(advanced-scene-switcher_UI ${advanced-scene-switcher_UI}
+                               forms/advanced-scene-switcher.ui)
+qt5_wrap_ui(advanced-scene-switcher_UI_HEADERS ${advanced-scene-switcher_UI}
+            ${advanced-scene-switcher_PLATFORM_UI})
 
+# The plugin sources
+set(advanced-scene-switcher_HEADERS
+    ${advanced-scene-switcher_HEADERS}
+    src/headers/advanced-scene-switcher.hpp
+    src/headers/switcher-data-structs.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-network.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-video.hpp
+    src/headers/switch-generic.hpp
+    src/headers/macro-action-edit.hpp
+    src/headers/macro-action-audio.hpp
+    src/headers/macro-action-file.hpp
+    src/headers/macro-action-filter.hpp
+    src/headers/macro-action-hotkey.hpp
+    src/headers/macro-action-macro.hpp
+    src/headers/macro-action-media.hpp
+    src/headers/macro-action-plugin-state.hpp
+    src/headers/macro-action-recording.hpp
+    src/headers/macro-action-replay-buffer.hpp
+    src/headers/macro-action-run.hpp
+    src/headers/macro-action-scene-order.hpp
+    src/headers/macro-action-scene-switch.hpp
+    src/headers/macro-action-scene-transform.hpp
+    src/headers/macro-action-scene-visibility.hpp
+    src/headers/macro-action-source.hpp
+    src/headers/macro-action-streaming.hpp
+    src/headers/macro-action-virtual-cam.hpp
+    src/headers/macro-action-wait.hpp
+    src/headers/macro-condition-edit.hpp
+    src/headers/macro-condition-audio.hpp
+    src/headers/macro-condition-cursor.hpp
+    src/headers/macro-condition-date.hpp
+    src/headers/macro-condition-file.hpp
+    src/headers/macro-condition-filter.hpp
+    src/headers/macro-condition-hotkey.hpp
+    src/headers/macro-condition-idle.hpp
+    src/headers/macro-condition-macro.hpp
+    src/headers/macro-condition-media.hpp
+    src/headers/macro-condition-plugin-state.hpp
+    src/headers/macro-condition-process.hpp
+    src/headers/macro-condition-recording.hpp
+    src/headers/macro-condition-replay-buffer.hpp
+    src/headers/macro-condition-scene-order.hpp
+    src/headers/macro-condition-scene.hpp
+    src/headers/macro-condition-source.hpp
+    src/headers/macro-condition-streaming.hpp
+    src/headers/macro-condition-timer.hpp
+    src/headers/macro-condition-video.hpp
+    src/headers/macro-condition-virtual-cam.hpp
+    src/headers/macro-condition-window.hpp
+    src/headers/macro.hpp
+    src/headers/macro-controls.hpp
+    src/headers/macro-segment.hpp
+    src/headers/macro-selection.hpp
+    src/headers/curl-helper.hpp
+    src/headers/hotkey.hpp
+    src/headers/scene-selection.hpp
+    src/headers/screenshot-helper.hpp
+    src/headers/name-dialog.hpp
+    src/headers/duration-control.hpp
+    src/headers/section.hpp
+    src/headers/platform-funcs.hpp
+    src/headers/utility.hpp
+    src/headers/volume-control.hpp
+    src/headers/version.h)
+
+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/switch-network.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-video.cpp
+    src/switch-generic.cpp
+    src/macro-action-edit.cpp
+    src/macro-action-audio.cpp
+    src/macro-action-file.cpp
+    src/macro-action-filter.cpp
+    src/macro-action-hotkey.cpp
+    src/macro-action-macro.cpp
+    src/macro-action-media.cpp
+    src/macro-action-plugin-state.cpp
+    src/macro-action-recording.cpp
+    src/macro-action-replay-buffer.cpp
+    src/macro-action-run.cpp
+    src/macro-action-scene-order.cpp
+    src/macro-action-scene-switch.cpp
+    src/macro-action-scene-transform.cpp
+    src/macro-action-scene-visibility.cpp
+    src/macro-action-source.cpp
+    src/macro-action-streaming.cpp
+    src/macro-action-virtual-cam.cpp
+    src/macro-action-wait.cpp
+    src/macro-condition-edit.cpp
+    src/macro-condition-audio.cpp
+    src/macro-condition-cursor.cpp
+    src/macro-condition-date.cpp
+    src/macro-condition-file.cpp
+    src/macro-condition-filter.cpp
+    src/macro-condition-hotkey.cpp
+    src/macro-condition-idle.cpp
+    src/macro-condition-macro.cpp
+    src/macro-condition-media.cpp
+    src/macro-condition-plugin-state.cpp
+    src/macro-condition-process.cpp
+    src/macro-condition-recording.cpp
+    src/macro-condition-replay-buffer.cpp
+    src/macro-condition-scene-order.cpp
+    src/macro-condition-scene.cpp
+    src/macro-condition-source.cpp
+    src/macro-condition-streaming.cpp
+    src/macro-condition-timer.cpp
+    src/macro-condition-video.cpp
+    src/macro-condition-virtual-cam.cpp
+    src/macro-condition-window.cpp
+    src/macro.cpp
+    src/macro-controls.cpp
+    src/macro-segment.cpp
+    src/macro-selection.cpp
+    src/macro-tab.cpp
+    src/curl-helper.cpp
+    src/scene-selection.cpp
+    src/screenshot-helper.cpp
+    src/name-dialog.cpp
+    src/duration-control.cpp
+    src/section.cpp
+    src/utility.cpp
+    src/volume-control.cpp
+    src/version.cpp)
+
+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})
+
+# Out of tree build
 if(BUILD_OUT_OF_TREE)
-	include_directories(
-		"${LIBOBS_INCLUDE_DIRS}"
-		"${LIBOBS_FRONTEND_INCLUDE_DIR}"
-		${Qt5Core_INCLUDES}
-		${Qt5Widgets_INCLUDES}
-		${LIBCURL_INCLUDE_DIRS})
+  target_link_libraries(
+    advanced-scene-switcher ${advanced-scene-switcher_PLATFORM_LIBS}
+    ${LIBOBS_LIB} ${LIBOBS_FRONTEND_API_LIB} Qt5::Core Qt5::Widgets)
 
-	target_link_libraries(advanced-scene-switcher
-		${advanced-scene-switcher_PLATFORM_LIBS}
-		${LIBOBS_LIB}
-		${LIBOBS_FRONTEND_API_LIB}
-		Qt5::Core
-		Qt5::Widgets)
+  # Additional commands to install the module in the correct place. Find all the
+  # translation files so we can copy them to the correct place later on.
+  file(GLOB ASS_TRANSLATION_FILES "data/locale/*.ini")
 
-	# Additional commands to install the module in the correct place.
-	# Find all the translation files so we can copy them to the correct
-	# place later on.
-	file(GLOB ASS_TRANSLATION_FILES
-			"data/locale/*.ini"
-			)
+  # OSX
+  if(APPLE)
+    set_target_properties(advanced-scene-switcher PROPERTIES PREFIX "")
+  endif()
 
-	# Windows
-	if(WIN32)
-		string(REGEX REPLACE "/RTC(su|[1su])" "" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}")
-		message("${CMAKE_CXX_FLAGS_RELEASE}")
-
-		find_package(w32-pthreads REQUIRED)
-
-		target_link_libraries(advanced-scene-switcher
-				w32-pthreads)
-	endif()
-
-	# OSX
-	if(APPLE)
-		set_target_properties(advanced-scene-switcher PROPERTIES PREFIX "")
-	endif()
-
-	# Linux
-	if(UNIX AND NOT APPLE)
-		set(CMAKE_C_FLAGS "-Wall -Wextra -Wvla -Wno-unused-function -Werror-implicit-function-declaration -Wno-missing-braces -Wno-missing-field-initializers ${CMAKE_C_FLAGS} -std=c99 -fno-strict-aliasing")
-
-		if(ARCH EQUAL 64)
-			set(ARCH_NAME "x86_64")
-		else()
-			set(ARCH_NAME "i686")
-		endif()
-
-		set_target_properties(advanced-scene-switcher PROPERTIES PREFIX "")
-
-		install(TARGETS advanced-scene-switcher
-				LIBRARY DESTINATION ${CMAKE_INSTALL_PREFIX}/lib/obs-plugins)
-		install(FILES ${ASS_TRANSLATION_FILES}
-				DESTINATION "${CMAKE_INSTALL_PREFIX}/share/obs/obs-plugins/advanced-scene-switcher/locale")
-	endif()
+  # Linux
+  if(UNIX AND NOT APPLE)
+    if(ARCH EQUAL 64)
+      set(ARCH_NAME "x86_64")
+    else()
+      set(ARCH_NAME "i686")
+    endif()
+    set_target_properties(advanced-scene-switcher PROPERTIES PREFIX "")
+    install(TARGETS advanced-scene-switcher
+            LIBRARY DESTINATION ${CMAKE_INSTALL_PREFIX}/lib/obs-plugins)
+    install(
+      FILES ${ASS_TRANSLATION_FILES}
+      DESTINATION
+        "${CMAKE_INSTALL_PREFIX}/share/obs/obs-plugins/advanced-scene-switcher/locale"
+    )
+  endif()
 else()
-	target_link_libraries(advanced-scene-switcher
-		${advanced-scene-switcher_PLATFORM_LIBS}
-		obs-frontend-api
-		Qt5::Widgets
-		libobs)
-
-	install_obs_plugin_with_data(advanced-scene-switcher data)
+  # In tree build
+  target_link_libraries(
+    advanced-scene-switcher ${advanced-scene-switcher_PLATFORM_LIBS}
+    obs-frontend-api Qt5::Widgets libobs)
+  install_obs_plugin_with_data(advanced-scene-switcher data)
 endif()

README.md

@@ -1,119 +1,27 @@
 # SceneSwitcher
 An automated scene switcher for OBS Studio
 
-More information can be found on https://obsproject.com/forum/resources/automatic-scene-switching.395/ and see https://github.com/WarmUpTill/SceneSwitcher/blob/master/CI/release/README.txt for installing releases.
+More information can be found on https://obsproject.com/forum/resources/automatic-scene-switching.395/.
 
-## Compiling in tree (recommended)
-Add the "SceneSwitcher" source directory to your obs-studio source directory under obs-studio/UI/frontend-plugins/:
+## Downloads
+
+Binaries for Windows, MacOS, and Linux are available in the [Releases](https://github.com/WarmUpTill/SceneSwitcher/releases) section.
+
+## Installing the plugin
+
+For the Windows and MacOS platforms, it is recommended to run the provided installers.
+
+For Linux the Snap package manager offers an OBS Studio installation which is bundled with the plugin:
 ```
-cd obs-studio/UI/frontend-plugins/
-git clone https://github.com/WarmUpTill/SceneSwitcher.git
+sudo snap install obs-studi
 ```
 
-Then modify the obs-studio/UI/frontend-plugins/CMakeLists.txt file and add an entry for the scene switcher:
-add_subdirectory(SceneSwitcher)
+If that is not an option you will have to ... 
+1. Copy the library to the plugins folder of you obs installation.
+2. Copy the contents of the data directory to its respective folders of your obs installation.
 
-## Compiling out of tree
-### Prerequisites
-You'll need CMake and a working development environment for OBS Studio installed
-on your computer. Once you've done that, do the following:
-```
-git clone https://github.com/WarmUpTill/SceneSwitcher.git
-cd SceneSwitcher
-mkdir build && cd build
-```
+Unfortunately the exact location of these folders may vary from system to system.
 
-### Windows
-In cmake-gui, you'll have to set these CMake variables :
-- **BUILD_OUT_OF_TREE** (bool) : true
-- **LIBOBS_INCLUDE_DIR** (path) : location of the libobs subfolder in the source
-code of OBS Studio, located at [source_directory]/libobs/.
-- **LIBOBS_LIB** (filepath) : location of the obs.dll file (usually set to
-C:\Program Files\obs-studio\bin\64bit\obs.dll)
+## Compiling the plugin
 
-Assuming that you installed Qt via the regular Qt App way:
-- **Qt5Core_DIR** (path) : C:/Qt/5.10.1/msvc2017_64/lib/cmake/Qt5Core
-- **Qt5Gui_DIR** (path): C:/Qt/5.10.1/msvc2017_64/lib/cmake/Qt5Gui
-- **Qt5Widgets_DIR** (path) : C:/Qt/5.10.1/msvc2017_64/lib/cmake/Qt5Widgets
-
-- **LIBOBS_FRONTEND_API_LIB** (filepath) : location of the libobs-frontend-api.dll
-file, usually C:/Program Files/obs-studio/bin/64bit/obs-frontend-api.dll
-(usually in the same place as LIBOBS_LIB)
-- **LIBOBS_FRONTEND_INCLUDE_DIR** (path) : location of the obs-frontend-api
-subfolder in the source code of OBS Studio, located at [source_directory]/UI/obs-frontend-api.
-
-Just keep hitting configure until all the vars are filled out. Then hit generate.
-
-### Linux
-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_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
-```
-
-For cmake-gui you'll have to set the following variables:
-- **BUILD_OUT_OF_TREE** (bool) : true
-- **LIBOBS_INCLUDE_DIR** (path) : location of the libobs subfolder in the source
-code of OBS Studio, located at [source_directory]/libobs/.
-- **LIBOBS_LIB** (filepath) : location of the libobs.so file (usually CMake finds
-this, but if not it'll usually be in /usr/lib/libobs.so)
-
-Assuming that you installed Qt via your system package manager, it should be 
-found automatically. If not, then usually you'll find it in something like:
-- **Qt5Core_DIR** (path) : /usr/lib64/cmake/Qt5Core
-- **Qt5Gui_DIR** (path): /usr/lib64/cmake/Qt5Gui
-- **Qt5Widgets_DIR** (path) : /usr/lib64/cmake/Qt5Widgets
-
-- **LIBOBS_FRONTEND_API_LIB** (filepath) : location of the libobs-frontend-api.so
-file (usually in the same place as LIBOBS_LIB)
-- **LIBOBS_FRONTEND_INCLUDE_DIR** (path) : location of the obs-frontend-api
-subfolder in the source code of OBS Studio, located at
-[source_directory]/UI/obs-frontend-api.
-
-Just keep hitting configure until all the vars are filled out. Then hit generate.
-
-Then open a terminal in the build folder and type:
-```
-make -j4
-sudo make install
-```
-NOTE: The Linux version of this plugin is dependent on libXScrnSaver.
-
-### OS X
-In cmake-gui, you'll have to set these CMake variables :
-- **BUILD_OUT_OF_TREE** (bool) : true
-- **LIBOBS_INCLUDE_DIR** (path) : location of the libobs subfolder in the source
-code of OBS Studio, located at [source_directory]/libobs/.
-- **LIBOBS_LIB** (filepath) : location of the libobs.0.dylib file (usually
-in /Applications/OBS.app/Contents/Resources/bin/libobs.0.dylib)
-
-Assuming that you installed Qt via the regular Qt App way:
-- **Qt5Core_DIR** (path) : Usually /Applications/Qt/5.10.1/clang_64/lib/cmake/Qt5Core
-- **Qt5Widgets_DIR** (path) : Usually /Applications/Qt/5.10.1/clang_64/lib/cmake/Qt5Widgets
-- **Qt5MacExtras_DIR** (path) : Usually /Applications/Qt/5.10.1/clang_64/lib/cmake/Qt5MacExtras
-
-- **LIBOBS_FRONTEND_API_LIB** (filepath) : location of the libobs-frontend-api.0.dylib
-file (usually in usually in /Applications/OBS.app/Contents/Resources/bin/libobs-frontend-api.0.dylib)
-- **LIBOBS_FRONTEND_INCLUDE_DIR** (path) : location of the obs-frontend-api subfolder
-in the source code of OBS Studio, located at [source_directory]/UI/obs-frontend-api.
-
-Just keep hitting configure until all the vars are filled out. Then hit generate.
-
-Open xcode (or a terminal, depending on the build type you chose), build and copy
-the advanced-scene-switcher.so file to /Applications/OBS.app/Contents/PlugIns
-
-Note that you might have to adjust the library search paths using the install_name_tool if you want the plugin to run on machines other than your build machine:
-```
-install_name_tool -change @rpath/libobs-frontend-api.dylib @executable_path/../Frameworks/libobs-frontend-api.dylib UI/frontend-plugins/SceneSwitcher/advanced-scene-switcher.so
-install_name_tool -change @rpath/libobs.0.dylib @executable_path/../Frameworks/libobs.0.dylib UI/frontend-plugins/SceneSwitcher/advanced-scene-switcher.so
-install_name_tool -change /usr/local/opt/qt5/lib/QtWidgets.framework/Versions/5/QtWidgets @executable_path/../Frameworks/QtWidgets.framework/Versions/5/QtWidgets UI/frontend-plugins/SceneSwitcher/advanced-scene-switcher.so
-install_name_tool -change /usr/local/opt/qt5/lib/QtGui.framework/Versions/5/QtGui @executable_path/../Frameworks/QtGui.framework/Versions/5/QtGui UI/frontend-plugins/SceneSwitcher/advanced-scene-switcher.so
-install_name_tool -change /usr/local/opt/qt5/lib/QtCore.framework/Versions/5/QtCore @executable_path/../Frameworks/QtCore.framework/Versions/5/QtCore UI/frontend-plugins/SceneSwitcher/advanced-scene-switcher.so
-```
+See the [build instructions](BUILDING.md).

data/locale/de-DE.ini

@@ -227,7 +227,9 @@ AdvSceneSwitcher.networkTab.Disabledwarning="Diese Funktionalität musste unter
 AdvSceneSwitcher.networkTab.server="Server starten (Sendet Szenenwechselnachrichten  zu allen verbundenen Clients)"
 AdvSceneSwitcher.networkTab.server.port="Port"
 AdvSceneSwitcher.networkTab.server.lockToIPv4="Nur IPv4 verwenden (deaktiviert IPv6)"
-AdvSceneSwitcher.networkTab.server.restrictSendToAutomatedSwitches="Sende nur Szenenwechselnachrichten  für automatisierte Szenenwechsel"
+AdvSceneSwitcher.networkTab.server.sendSceneChange="Sende Nachrichten für Szenenwechsel"
+AdvSceneSwitcher.networkTab.server.restrictSendToAutomatedSwitches="Sende nur Szenenwechselnachrichten für automatisierte Szenenwechsel"
+AdvSceneSwitcher.networkTab.server.sendPreview="Sende Nachrichten für Vorschau Szenenwechsel im Studio-Modus"
 AdvSceneSwitcher.networkTab.startFailed.message="Der WebSocket-Server konnte nicht gestartet werden, mögliche Gründe:\n - Der TCP-Port %1 wird möglicherweise gerade von einem anderen Programm verwendet. Versuchen Sie einen anderen Port in den Websocket-Servereinstellungen zu setzen oder alle Programme zu beenden, die den Port möglicherweise verwenden.\n - Fehler: %2"
 AdvSceneSwitcher.networkTab.server.status.currentStatus="Aktueller Status"
 AdvSceneSwitcher.networkTab.server.status.notRunning="Nicht gestartet"
@@ -282,6 +284,8 @@ AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.muteSource="Audio Quelle stu
 AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.unmuteSource="Audio Quelle aktiv schalten"
 AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.startSwitcher="Szenenwechsler starten"
 AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.stopSwitcher="Szenenwechsler stoppen"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.startVirtualCamera="Virtuelle Kamera starten"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.stopVirtualCamera="Virtuelle Kamera stoppen"
 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."
 

data/locale/en-US.ini

@@ -57,8 +57,8 @@ AdvSceneSwitcher.generalTab.priority.macro="Macro"
 AdvSceneSwitcher.macroTab.title="Macro"
 AdvSceneSwitcher.macroTab.macros="Macros"
 AdvSceneSwitcher.macroTab.help="Macros allow you to execute a string of actions depending on multiple conditions.\n\nClick on the highlighted plus symbol to add a new Macro."
-AdvSceneSwitcher.macroTab.editConditionHelp="This section allows you to define Macro conditions.\n\nSelect an existing or add a new Macro on the left."
-AdvSceneSwitcher.macroTab.editActionHelp="This section allows you to define Macro actions.\n\nSelect an existing or add a new Macro on the left."
+AdvSceneSwitcher.macroTab.editConditionHelp="This section allows you to define Macro conditions.\n\nSelect an existing or add a new Macro on the left.\nThen click the plus button below to add a new condition."
+AdvSceneSwitcher.macroTab.editActionHelp="This section allows you to define Macro actions.\n\nSelect an existing or add a new Macro on the left.\nThen click the plus button below to add a new action."
 AdvSceneSwitcher.macroTab.edit="Edit macro"
 AdvSceneSwitcher.macroTab.edit.logic="Logic type:"
 AdvSceneSwitcher.macroTab.edit.condition="Condition type:"
@@ -68,6 +68,9 @@ AdvSceneSwitcher.macroTab.name="Name:"
 AdvSceneSwitcher.macroTab.defaultname="Macro %1"
 AdvSceneSwitcher.macroTab.exists="Macro name exists already"
 AdvSceneSwitcher.macroTab.copy="Create copy"
+AdvSceneSwitcher.macroTab.expandAll="Expand all"
+AdvSceneSwitcher.macroTab.collapseAll="Collapse all"
+
 ; Macro Logic
 AdvSceneSwitcher.logic.none="Ignore entry"
 AdvSceneSwitcher.logic.and="And"
@@ -76,20 +79,26 @@ AdvSceneSwitcher.logic.andNot="And not"
 AdvSceneSwitcher.logic.orNot="Or not"
 AdvSceneSwitcher.logic.rootNone="If"
 AdvSceneSwitcher.logic.not="If not"
+
 ; Macro Conditions
 AdvSceneSwitcher.condition.audio="Audio"
-AdvSceneSwitcher.ondition.audio.state.below="Below"
-AdvSceneSwitcher.ondition.audio.state.above="Above"
-AdvSceneSwitcher.condition.audio.entry="Volume of {{audioSources}} is {{condition}} {{volume}} for {{duration}} seconds"
-AdvSceneSwitcher.condition.region="Screen region"
-AdvSceneSwitcher.condition.region.entry="Cursor is in {{minX}} {{minY}} x {{maxX}} {{maxY}}"
+AdvSceneSwitcher.condition.audio.state.below="Below"
+AdvSceneSwitcher.condition.audio.state.above="Above"
+AdvSceneSwitcher.condition.audio.entry="Volume of {{audioSources}} is {{condition}} {{volume}}"
+AdvSceneSwitcher.condition.cursor="Cursor"
+AdvSceneSwitcher.condition.cursor.type.region="is in region"
+AdvSceneSwitcher.condition.cursor.type.moving="is moving"
+AdvSceneSwitcher.condition.cursor.showFrame="Show frame"
+AdvSceneSwitcher.condition.cursor.hideFrame="Hide frame"
+AdvSceneSwitcher.condition.cursor.entry.line1="Cursor is {{conditions}} {{minX}} {{minY}} {{maxX}} {{maxY}} - {{toggleFrameButton}}"
+AdvSceneSwitcher.condition.cursor.entry.line2="Cursor is currently at {{xPos}} x {{yPos}}"
 AdvSceneSwitcher.condition.scene="Scene"
 AdvSceneSwitcher.condition.scene.type.current="Current"
 AdvSceneSwitcher.condition.scene.type.previous="Previous"
-AdvSceneSwitcher.condition.scene.entry="{{sceneType}} scene is {{scenes}} for {{duration}}"
+AdvSceneSwitcher.condition.scene.entry="{{sceneType}} scene is {{scenes}}"
 AdvSceneSwitcher.condition.window="Window"
 AdvSceneSwitcher.condition.window.entry.line1="{{windows}} exist and ..."
-AdvSceneSwitcher.condition.window.entry.line2="... is {{fullscreen}} fullscreen {{maximized}} maximized {{focused}} focused"
+AdvSceneSwitcher.condition.window.entry.line2="... is {{fullscreen}} fullscreen {{maximized}} maximized {{focused}} focused {{windowFocusChanged}} foreground window changed"
 AdvSceneSwitcher.condition.file="File"
 AdvSceneSwitcher.condition.file.entry.line1="Content of {{fileType}} {{filePath}} {{browseButton}} matches:"
 AdvSceneSwitcher.condition.file.entry.line2="{{matchText}}"
@@ -105,16 +114,16 @@ AdvSceneSwitcher.condition.video.condition.noImage="has no output"
 AdvSceneSwitcher.condition.video.askFileAction="Do you want to use an existing file or create a screenshot of the currently selected source?"
 AdvSceneSwitcher.condition.video.askFileAction.file="Use existing file"
 AdvSceneSwitcher.condition.video.askFileAction.screenshot="Create screenshot"
-AdvSceneSwitcher.condition.video.entry="{{videoSources}} {{condition}} {{filePath}} {{browseButton}} for {{duration}}"
+AdvSceneSwitcher.condition.video.entry="{{videoSources}} {{condition}} {{filePath}} {{browseButton}}"
 AdvSceneSwitcher.condition.stream="Streaming"
 AdvSceneSwitcher.condition.stream.state.start="Stream running"
 AdvSceneSwitcher.condition.stream.state.stop="Stream stopped"
-AdvSceneSwitcher.condition.stream.entry="{{streamState}} for {{duration}}"
+AdvSceneSwitcher.condition.stream.entry="{{streamState}}"
 AdvSceneSwitcher.condition.record="Recording"
 AdvSceneSwitcher.condition.record.state.start="Recording running"
 AdvSceneSwitcher.condition.record.state.pause="Recording paused"
 AdvSceneSwitcher.condition.record.state.stop="Recording stopped"
-AdvSceneSwitcher.condition.record.entry="{{recordState}} for {{duration}}"
+AdvSceneSwitcher.condition.record.entry="{{recordState}}"
 AdvSceneSwitcher.condition.process="Process"
 AdvSceneSwitcher.condition.process.entry="{{processes}} is running {{focused}} and is focused"
 AdvSceneSwitcher.condition.idle="Idle"
@@ -122,6 +131,66 @@ AdvSceneSwitcher.condition.idle.entry="No keyboard or mouse inputs for {{duratio
 AdvSceneSwitcher.condition.pluginState="Plugin state"
 AdvSceneSwitcher.condition.pluginState.state.sceneSwitched="Automated scene change was triggered in this interval"
 AdvSceneSwitcher.condition.pluginState.entry="{{condition}}"
+AdvSceneSwitcher.condition.timer="Timer"
+AdvSceneSwitcher.condition.timer.entry.line1="{{duration}} have passed"
+AdvSceneSwitcher.condition.timer.entry.line2="Time remaining: {{remaining}} seconds"
+AdvSceneSwitcher.condition.timer.entry.line3="{{reset}} {{autoReset}} Automatically reset timer after duration was reached"
+AdvSceneSwitcher.condition.timer.reset="Reset"
+AdvSceneSwitcher.condition.macro="Macro"
+AdvSceneSwitcher.condition.macro.type.count="Count"
+AdvSceneSwitcher.condition.macro.type.state="State"
+AdvSceneSwitcher.condition.macro.type.selection="Condition type: {{types}}"
+AdvSceneSwitcher.condition.macro.count.type.below="Less than"
+AdvSceneSwitcher.condition.macro.count.type.above="More than"
+AdvSceneSwitcher.condition.macro.count.type.equal="Exactly"
+AdvSceneSwitcher.condition.macro.count.reset="Reset"
+AdvSceneSwitcher.condition.macro.state.entry="Conditions of {{macros}} are true"
+AdvSceneSwitcher.condition.macro.count.entry.line1="{{macros}} was executed {{conditions}} {{count}} times"
+AdvSceneSwitcher.condition.macro.count.entry.line2="Current count: {{currentCount}} {{resetCount}}"
+AdvSceneSwitcher.condition.source="Source"
+AdvSceneSwitcher.condition.source.type.active="Is active"
+AdvSceneSwitcher.condition.source.type.showing="Is showing"
+AdvSceneSwitcher.condition.source.type.settings="Settings match"
+AdvSceneSwitcher.condition.source.regex="Use regular expressions"
+AdvSceneSwitcher.condition.source.getSettings="Get current settings"
+AdvSceneSwitcher.condition.source.entry.line1="{{sources}} {{conditions}}"
+AdvSceneSwitcher.condition.source.entry.line2="{{settings}}"
+AdvSceneSwitcher.condition.source.entry.line3="{{regex}} {{getSettings}}"
+AdvSceneSwitcher.condition.virtualCamera="Virtual camera"
+AdvSceneSwitcher.condition.virtualCamera.state.start="Virtual camera started"
+AdvSceneSwitcher.condition.virtualCamera.state.stop="Virtual camera stopped"
+AdvSceneSwitcher.condition.virtualCamera.entry="{{states}}"
+AdvSceneSwitcher.condition.filter="Filter"
+AdvSceneSwitcher.condition.filter.type.active="Is enabled"
+AdvSceneSwitcher.condition.filter.type.showing="Is disabled"
+AdvSceneSwitcher.condition.filter.type.settings="Settings match"
+AdvSceneSwitcher.condition.filter.regex="Use regular expressions"
+AdvSceneSwitcher.condition.filter.getSettings="Get current settings"
+AdvSceneSwitcher.condition.filter.entry.line1="On {{sources}} {{filters}} {{conditions}}"
+AdvSceneSwitcher.condition.filter.entry.line2="{{settings}}"
+AdvSceneSwitcher.condition.filter.entry.line3="{{regex}} {{getSettings}}"
+AdvSceneSwitcher.condition.sceneOrder="Scene item order"
+AdvSceneSwitcher.condition.sceneOrder.type.above="Is above"
+AdvSceneSwitcher.condition.sceneOrder.type.below="Is below"
+AdvSceneSwitcher.condition.sceneOrder.type.position="Is at position"
+AdvSceneSwitcher.condition.sceneOrder.positionInfo="The position value starts at the bottom with 0 and increases by one for each scene item including the ones in scene groups"
+AdvSceneSwitcher.condition.sceneOrder.entry="On {{scenes}} {{sources}} {{conditions}} {{sources2}} {{position}}"
+AdvSceneSwitcher.condition.hotkey="Hotkey"
+AdvSceneSwitcher.condition.hotkey.name="Macro trigger hotkey"
+AdvSceneSwitcher.condition.hotkey.tip="Note: You can configure the keybindings for this hotkey in the OBS settings window"
+AdvSceneSwitcher.condition.hotkey.entry="Name: {{name}}"
+AdvSceneSwitcher.condition.replay="Replay buffer"
+AdvSceneSwitcher.condition.replay.state.stopped="Replay buffer stopped"
+AdvSceneSwitcher.condition.replay.state.started="Replay buffer started"
+AdvSceneSwitcher.condition.replay.state.saved="Replay buffer saved"
+AdvSceneSwitcher.condition.replay.entry="{{state}}"
+AdvSceneSwitcher.condition.date="Date"
+AdvSceneSwitcher.condition.date.state.at="At"
+AdvSceneSwitcher.condition.date.state.after="After"
+AdvSceneSwitcher.condition.date.state.before="Before"
+AdvSceneSwitcher.condition.date.state.between="Between"
+AdvSceneSwitcher.condition.date.entry.line1="{{condition}} {{dateTime}} {{dateTime2}} {{ignoreDate}} Ignore date component {{ignoreTime}} Ignore time component"
+AdvSceneSwitcher.condition.date.entry.line2="{{repeat}} Reschedule {{duration}} later when matching"
 
 ; Macro Actions
 AdvSceneSwitcher.action.switchScene="Switch scene"
@@ -154,8 +223,73 @@ AdvSceneSwitcher.action.streaming.type.stop="Stop streaming"
 AdvSceneSwitcher.action.streaming.type.start="Start streaming"
 AdvSceneSwitcher.action.streaming.entry="{{actions}}"
 AdvSceneSwitcher.action.run="Run"
+AdvSceneSwitcher.action.run.arguments="Arguments:"
+AdvSceneSwitcher.action.run.addArgument="Add argument"
+AdvSceneSwitcher.action.run.addArgumentDescription="Add new argument:"
 AdvSceneSwitcher.action.run.entry="Run {{filePath}} {{browseButton}}"
-
+AdvSceneSwitcher.action.sceneVisibility="Scene item visibility"
+AdvSceneSwitcher.action.sceneVisibility.type.show="Show"
+AdvSceneSwitcher.action.sceneVisibility.type.hide="Hide"
+AdvSceneSwitcher.action.sceneVisibility.entry="On {{scenes}} {{actions}} {{sources}}"
+AdvSceneSwitcher.action.filter="Filter"
+AdvSceneSwitcher.action.filter.type.enable="Enable"
+AdvSceneSwitcher.action.filter.type.disable="Disable"
+AdvSceneSwitcher.action.filter.type.settings="Set settings"
+AdvSceneSwitcher.action.filter.entry="On {{sources}} {{actions}} {{filters}}"
+AdvSceneSwitcher.action.filter.getSettings="Get current settings"
+AdvSceneSwitcher.action.source="Source"
+AdvSceneSwitcher.action.source.type.enable="Enable"
+AdvSceneSwitcher.action.source.type.disable="Disable"
+AdvSceneSwitcher.action.source.type.settings="Set settings"
+AdvSceneSwitcher.action.source.entry="{{actions}} {{sources}}"
+AdvSceneSwitcher.action.source.warning="Warning: Enabling and disabling sources globally cannot be controlled by the OBS UI"
+AdvSceneSwitcher.action.source.getSettings="Get current settings"
+AdvSceneSwitcher.action.media="Media"
+AdvSceneSwitcher.action.media.type.play="Play"
+AdvSceneSwitcher.action.media.type.pause="Pause"
+AdvSceneSwitcher.action.media.type.stop="Stop"
+AdvSceneSwitcher.action.media.type.restart="Restart"
+AdvSceneSwitcher.action.media.type.next="Next"
+AdvSceneSwitcher.action.media.type.previous="Previous"
+AdvSceneSwitcher.action.media.entry="{{actions}} {{mediaSources}}"
+AdvSceneSwitcher.action.macro="Macro"
+AdvSceneSwitcher.action.macro.type.pause="Pause"
+AdvSceneSwitcher.action.macro.type.unpause="Unpause"
+AdvSceneSwitcher.action.macro.type.resetCounter="Reset counter"
+AdvSceneSwitcher.action.macro.entry="{{actions}} {{macros}}"
+AdvSceneSwitcher.action.pluginState="Plugin state"
+AdvSceneSwitcher.action.pluginState.type.stop="Stop the Advanced Scene Switcher plugin"
+AdvSceneSwitcher.action.pluginState.type.noMatch="Change the no-match behaviour:"
+AdvSceneSwitcher.action.pluginState.entry="{{actions}} {{values}} {{scenes}}"
+AdvSceneSwitcher.action.virtualCamera="Virtual camera"
+AdvSceneSwitcher.action.virtualCamera.type.stop="Stop virtual camera"
+AdvSceneSwitcher.action.virtualCamera.type.start="Start virtual camera"
+AdvSceneSwitcher.action.virtualCamera.entry="{{actions}}"
+AdvSceneSwitcher.action.hotkey="Hotkey"
+AdvSceneSwitcher.action.hotkey.leftShift="Left Shift"
+AdvSceneSwitcher.action.hotkey.rightShift="Right Shift"
+AdvSceneSwitcher.action.hotkey.leftCtrl="Left Ctrl"
+AdvSceneSwitcher.action.hotkey.rightCtrl="Right Ctrl"
+AdvSceneSwitcher.action.hotkey.leftAlt="Left Alt"
+AdvSceneSwitcher.action.hotkey.rightAlt="Right Alt"
+AdvSceneSwitcher.action.hotkey.leftMeta="Left Meta"
+AdvSceneSwitcher.action.hotkey.rightMeta="Right Meta"
+AdvSceneSwitcher.action.hotkey.disabled="Cannot simulate key presses - functionality disabled!"
+AdvSceneSwitcher.action.hotkey.entry="Press {{keys}}"
+AdvSceneSwitcher.action.sceneOrder="Scene item order"
+AdvSceneSwitcher.action.sceneOrder.type.moveUp="Move up"
+AdvSceneSwitcher.action.sceneOrder.type.moveDown="Move down"
+AdvSceneSwitcher.action.sceneOrder.type.moveTop="Move to top"
+AdvSceneSwitcher.action.sceneOrder.type.moveBottom="Move to bottom"
+AdvSceneSwitcher.action.sceneOrder.type.movePosition="Move to position"
+AdvSceneSwitcher.action.sceneOrder.entry="On {{scenes}} {{actions}} {{sources}} {{position}}"
+AdvSceneSwitcher.action.sceneTransform="Scene item transform"
+AdvSceneSwitcher.action.sceneTransform.getTransform="Get transform"
+AdvSceneSwitcher.action.sceneTransform.entry="On {{scenes}} transform {{sources}}"
+AdvSceneSwitcher.action.file="File"
+AdvSceneSwitcher.action.file.type.write="Write"
+AdvSceneSwitcher.action.file.type.append="Append"
+AdvSceneSwitcher.action.file.entry="{{actions}} to {{filePath}} {{browseButton}}:"
 
 ; Transition Tab
 AdvSceneSwitcher.transitionTab.title="Transition"
@@ -327,12 +461,15 @@ AdvSceneSwitcher.videoTab.help="<html><head/><body><p>This tab will allow you to
 
 ; Network Tab
 AdvSceneSwitcher.networkTab.title="Network"
+AdvSceneSwitcher.networkTab.description="This tab will allow you to remotely control the active scene of another OBS instance.\nPlease note that the scene names have to match exactly on all OBS instances."
 AdvSceneSwitcher.networkTab.warning="Running the server outside of a local network will allow third parties to read the active scene."
 AdvSceneSwitcher.networkTab.DisabledWarning="This functionality unfortunately had to be disabled on macOS due to library incompatibilities when running the obs-websocket plugin in parallel."
 AdvSceneSwitcher.networkTab.server="Start server (Sends scene switch messages to all connected clients)"
 AdvSceneSwitcher.networkTab.server.port="Port"
 AdvSceneSwitcher.networkTab.server.lockToIPv4="Lock server to only using IPv4"
+AdvSceneSwitcher.networkTab.server.sendSceneChange="Send messages for scene changes"
 AdvSceneSwitcher.networkTab.server.restrictSendToAutomatedSwitches="Only send messages for automated scene switches"
+AdvSceneSwitcher.networkTab.server.sendPreview="Send messages for preview scene change when running in Studio mode"
 AdvSceneSwitcher.networkTab.startFailed.message="The WebSockets server failed to start, maybe because:\n - TCP port %1 may currently be in use elsewhere on this system, possibly by another application. Try setting a different TCP port in the WebSocket server settings, or stop any application that could be using this port.\n - Error message: %2"
 AdvSceneSwitcher.networkTab.server.status.currentStatus="Current status"
 AdvSceneSwitcher.networkTab.server.status.notRunning="Not running"
@@ -387,6 +524,8 @@ AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.muteSource="mute source"
 AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.unmuteSource="unmute source"
 AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.startSwitcher="start the scene switcher"
 AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.stopSwitcher="stop the scene switcher"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.startVirtualCamera="start virtual camera"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.stopVirtualCamera="stop virtual camera"
 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."
 
@@ -394,6 +533,8 @@ AdvSceneSwitcher.sceneTriggerTab.help="This tab allows you to trigger actions on
 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.hotkey.macro.pause="Pause macro %1"
+AdvSceneSwitcher.hotkey.macro.unpause="Unpause macro %1"
 
 AdvSceneSwitcher.askBackup="Detected a new version of the Advanced Scene Switcher.\nShould a backup of the old settings be created?"
 
@@ -402,13 +543,19 @@ AdvSceneSwitcher.browse="Browse"
 
 AdvSceneSwitcher.selectScene="--select scene--"
 AdvSceneSwitcher.selectPreviousScene="Previous Scene"
+AdvSceneSwitcher.selectCurrentScene="Current Scene"
+AdvSceneSwitcher.selectAnyScene="Any Scene"
 AdvSceneSwitcher.currentTransition="Current Transition"
 AdvSceneSwitcher.selectTransition="--select transition--"
 AdvSceneSwitcher.selectWindow="--select window--"
+AdvSceneSwitcher.selectSource="--select source--"
 AdvSceneSwitcher.selectAudioSource="--select audio source--"
 AdvSceneSwitcher.selectVideoSource="--select video source--"
 AdvSceneSwitcher.selectMediaSource="--select media source--"
 AdvSceneSwitcher.selectProcess="--select process--"
+AdvSceneSwitcher.selectFilter="--select filter--"
+AdvSceneSwitcher.selectMacro="--select macro--"
+AdvSceneSwitcher.selectItem="--select item--"
 AdvSceneSwitcher.enterPath="--enter path--"
 AdvSceneSwitcher.enterText="--enter text--"
 AdvSceneSwitcher.invaildEntriesWillNotBeSaved="invalid entries will not be saved"
@@ -421,3 +568,7 @@ AdvSceneSwitcher.unit.milliseconds="milliseconds"
 AdvSceneSwitcher.unit.secends="seconds"
 AdvSceneSwitcher.unit.minutes="minutes"
 AdvSceneSwitcher.unit.hours="hours"
+AdvSceneSwitcher.duration.condition.none="No time constraint"
+AdvSceneSwitcher.duration.condition.more="For at least"
+AdvSceneSwitcher.duration.condition.equal="For exactly"
+AdvSceneSwitcher.duration.condition.less="For at most"

data/locale/ru-RU.ini

@@ -0,0 +1,422 @@
+AdvSceneSwitcher.pluginName="Advanced Scene Switcher"
+AdvSceneSwitcher.windowTitle="Advanced Scene Switcher"
+
+; General Tab
+AdvSceneSwitcher.generalTab.title="Общие"
+AdvSceneSwitcher.generalTab.status="Статус"
+AdvSceneSwitcher.generalTab.status.hotkeytips="Горячие клавиши можно определить в настройках OBS"
+AdvSceneSwitcher.generalTab.status.currentStatus="Advanced Scene Switcher сейчас:"
+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="Автоматически запускать переключатель сцен, когда:"
+AdvSceneSwitcher.generalTab.status.autoStart.never="Никогда"
+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="Переключиться на любую сцену на вкладке Random"
+AdvSceneSwitcher.generalTab.generalBehavior.onNoMet.switchTo="Переключиться на:"
+AdvSceneSwitcher.generalTab.generalBehavior.cooldown="После совпадения не переключаться между сценами в течение"
+AdvSceneSwitcher.generalTab.generalBehavior.cooldownHint="В течение этого времени потенциальные совпадения будут игнорироваться!"
+AdvSceneSwitcher.generalTab.generalBehavior.verboseLogging="Включить ведение подробного журнала"
+AdvSceneSwitcher.generalTab.generalBehavior.saveWindowGeo="Сохранять положение и размер окна"
+AdvSceneSwitcher.generalTab.generalBehavior.disableUIHints="Отключить подсказки пользовательского интерфейса"
+AdvSceneSwitcher.generalTab.priority="Приоритет"
+AdvSceneSwitcher.generalTab.priority.description="Приоритет методов переключения (самый высокий приоритет - вверху)"
+AdvSceneSwitcher.generalTab.priority.threadPriority="Использовать приоритет потока"
+AdvSceneSwitcher.generalTab.priority.threadPriorityNotice="(Поднимать приоритет выше \"Нормальный\" не рекомендуется)"
+AdvSceneSwitcher.generalTab.saveOrLoadsettings="Сохранить / загрузить настройки"
+AdvSceneSwitcher.generalTab.saveOrLoadsettings.export="Экспорт"
+AdvSceneSwitcher.generalTab.saveOrLoadsettings.import="Импорт"
+AdvSceneSwitcher.generalTab.saveOrLoadsettings.exportWindowTitle="Экспортировать настройки расширенного переключателя сцен в файл ..."
+AdvSceneSwitcher.generalTab.saveOrLoadsettings.importWindowTitle="Импортировать настройки Advanced Scene Switcher из файла ..."
+AdvSceneSwitcher.generalTab.saveOrLoadsettings.textType="Текстовые файлы (*.txt)"
+AdvSceneSwitcher.generalTab.saveOrLoadsettings.loadFail="Advanced Scene Switcher не удалось импортировать настройки"
+AdvSceneSwitcher.generalTab.saveOrLoadsettings.loadSuccess="Настройки Advanced Scene Switcher импортированы успешно"
+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="Аудио"
+AdvSceneSwitcher.generalTab.priority.video="Видео"
+AdvSceneSwitcher.generalTab.priority.macro="Макрос"
+
+; Macro Tab
+AdvSceneSwitcher.macroTab.title="Макрос"
+AdvSceneSwitcher.macroTab.macros="Макросы"
+AdvSceneSwitcher.macroTab.help="Макросы позволяют выполнять ряд действий в зависимости от нескольких условий.\n\nНажмите на выделенный символ плюса, чтобы добавить новый макрос."
+AdvSceneSwitcher.macroTab.editConditionHelp="Этот раздел позволяет определить условия макроса.\n\nВыберите существующий или добавьте новый макрос слева."
+AdvSceneSwitcher.macroTab.editActionHelp="Этот раздел позволяет определить действия макроса.\n\n\nВыберите существующий или добавьте новый макрос слева."
+AdvSceneSwitcher.macroTab.edit="Редактировать макрос"
+AdvSceneSwitcher.macroTab.edit.logic="Тип логики:"
+AdvSceneSwitcher.macroTab.edit.condition="Тип условия:"
+AdvSceneSwitcher.macroTab.edit.action="Тип действия:"
+AdvSceneSwitcher.macroTab.add="Добавить новый макрос"
+AdvSceneSwitcher.macroTab.name="Имя:"
+AdvSceneSwitcher.macroTab.defaultname="Макрос %1"
+AdvSceneSwitcher.macroTab.exists="Имя макроса уже существует"
+AdvSceneSwitcher.macroTab.copy="Создать копию"
+; Macro Logic
+AdvSceneSwitcher.logic.none="Игнорировать вход"
+AdvSceneSwitcher.logic.and="И"
+AdvSceneSwitcher.logic.or="Или"
+AdvSceneSwitcher.logic.andNot="И не"
+AdvSceneSwitcher.logic.orNot="Или нет"
+AdvSceneSwitcher.logic.rootNone="Если"
+AdvSceneSwitcher.logic.not="Если нет"
+; Macro Conditions
+AdvSceneSwitcher.condition.audio="Аудио"
+AdvSceneSwitcher.ondition.audio.state.below="Ниже"
+AdvSceneSwitcher.ondition.audio.state.above="Выше"
+AdvSceneSwitcher.condition.audio.entry="Громкость {{audioSources}} равна {{condition}} {{volume}} в течении {{duration}} секунд"
+AdvSceneSwitcher.condition.cursor="Область экрана"
+AdvSceneSwitcher.condition.scene="Сцена"
+AdvSceneSwitcher.condition.scene.type.current="Текущий"
+AdvSceneSwitcher.condition.scene.type.previous="Предыдущий"
+AdvSceneSwitcher.condition.scene.entry="{{sceneType}} сцена является {{scenes}} на {{duration}}"
+AdvSceneSwitcher.condition.window="Окно"
+AdvSceneSwitcher.condition.window.entry.line1="{{windows}} существует и ..."
+AdvSceneSwitcher.condition.window.entry.line2="... это {{fullscreen}} полноэкранный {{maximized}} максимизированный {{focused}} сфокусированный"
+AdvSceneSwitcher.condition.file="Файл"
+AdvSceneSwitcher.condition.file.entry.line1="Содержимое {{fileType}} {{filePath}} {{browseButton}} соответствует:"
+AdvSceneSwitcher.condition.file.entry.line2="{{matchText}}"
+AdvSceneSwitcher.condition.file.entry.line3="{{useRegex}} {{checkModificationDate}} {{checkFileContent}}"
+AdvSceneSwitcher.condition.media="Медиа"
+AdvSceneSwitcher.condition.media.entry="{{mediaSources}} состояние {{states}} и {{timeRestrictions}} {{time}}"
+AdvSceneSwitcher.condition.video="Видео"
+AdvSceneSwitcher.condition.video.condition.match="точно соответствует"
+AdvSceneSwitcher.condition.video.condition.differ="не совпадает"
+AdvSceneSwitcher.condition.video.condition.hasChanged="изменилось"
+AdvSceneSwitcher.condition.video.condition.hasNotChanged="не изменилось"
+AdvSceneSwitcher.condition.video.condition.noImage="не имеет вывода"
+AdvSceneSwitcher.condition.video.askFileAction="Вы хотите использовать существующий файл или создать скриншот текущего выбранного источника?"
+AdvSceneSwitcher.condition.video.askFileAction.file="Использовать существующий файл"
+AdvSceneSwitcher.condition.video.askFileAction.screenshot="Создать скриншот"
+AdvSceneSwitcher.condition.video.entry="{{videoSources}} {{condition}} {{filePath}} {{browseButton}} для {{duration}}"
+AdvSceneSwitcher.condition.stream="Потоковое вещание"
+AdvSceneSwitcher.condition.stream.state.start="Поток запущен"
+AdvSceneSwitcher.condition.stream.state.stop="Поток остановлен"
+AdvSceneSwitcher.condition.stream.entry="{{streamState}} для {{duration}}"
+AdvSceneSwitcher.condition.record="Запись"
+AdvSceneSwitcher.condition.record.state.start="Запись запущена"
+AdvSceneSwitcher.condition.record.state.pause="Запись приостановлена"
+AdvSceneSwitcher.condition.record.state.stop="Запись остановлена"
+AdvSceneSwitcher.condition.record.entry="{{recordState}} для {{duration}}"
+AdvSceneSwitcher.condition.process="Процесс"
+AdvSceneSwitcher.condition.process.entry="{{processes}} запущен {{focused}} и сфокусирован"
+AdvSceneSwitcher.condition.idle="Простой"
+AdvSceneSwitcher.condition.idle.entry="Не было ни клавиатуры, ни мыши в течении{{duration}}"
+AdvSceneSwitcher.condition.pluginState="Состояние плагина"
+AdvSceneSwitcher.condition.pluginState.state.sceneSwitched="Автоматическая смена сцены была запущена в этом интервале"
+AdvSceneSwitcher.condition.pluginState.entry="{{condition}}"
+
+; Macro Actions
+AdvSceneSwitcher.action.switchScene="Переключить сцену"
+AdvSceneSwitcher.action.scene.entry="Перейти к сцене {{scenes}} используя {{transitions}} с продолжительностью {{duration}} секунд"
+AdvSceneSwitcher.action.wait="Подождать"
+AdvSceneSwitcher.action.wait.type.fixed="фиксированный"
+AdvSceneSwitcher.action.wait.type.random="случайный"
+AdvSceneSwitcher.action.wait.entry.fixed="Ожидать {{waitType}} в течении {{duration}}"
+AdvSceneSwitcher.action.wait.entry.random="Ожидание {{waitType}} длительностью от {{duration}} до {{duration2}}"
+AdvSceneSwitcher.action.audio="Аудио"
+AdvSceneSwitcher.action.audio.type.mute="Замьютить"
+AdvSceneSwitcher.action.audio.type.unmute="Размьютить"
+AdvSceneSwitcher.action.audio.type.sourceVolume="Установить громкость источника"
+AdvSceneSwitcher.action.audio.type.masterVolume="Установить главную громкость"
+AdvSceneSwitcher.action.audio.entry="{{actions}} {{audioSources}} {{volume}}"
+AdvSceneSwitcher.action.recording="Запись"
+AdvSceneSwitcher.action.recording.type.stop="Остановить запись"
+AdvSceneSwitcher.action.recording.type.start="Начать запись"
+AdvSceneSwitcher.action.recording.type.pause="Пауза записи"
+AdvSceneSwitcher.action.recording.type.unpause="Снять запись с паузы"
+AdvSceneSwitcher.action.recording.pause.hint="Обратите внимание, что в зависимости от настроек записи вы можете не иметь возможности приостановить запись"
+AdvSceneSwitcher.action.recording.entry="{{actions}}{{pauseHint}}"
+AdvSceneSwitcher.action.replay="Буфер воспроизведения"
+AdvSceneSwitcher.action.replay.type.stop="Остановить буфер воспроизведения"
+AdvSceneSwitcher.action.replay.type.start="Начать воспроизведение буфера"
+AdvSceneSwitcher.action.replay.type.save="Сохранить буфер воспроизведения"
+AdvSceneSwitcher.action.replay.entry="{{actions}}"
+AdvSceneSwitcher.action.streaming="Потоковое вещание"
+AdvSceneSwitcher.action.streaming.type.stop="Остановить потоковое вещание"
+AdvSceneSwitcher.action.streaming.type.start="Начать потоковое вещание"
+AdvSceneSwitcher.action.streaming.entry="{{actions}}"
+AdvSceneSwitcher.action.run="Запустить"
+AdvSceneSwitcher.action.run.entry="Запустить {{filePath}} {{browseButton}}"
+
+
+; Transition Tab
+AdvSceneSwitcher.transitionTab.title="Переход"
+AdvSceneSwitcher.transitionTab.setTransitionBy="При изменении переходов:"
+AdvSceneSwitcher.transitionTab.transitionOverride="Установить переопределение переходов"
+AdvSceneSwitcher.transitionTab.adjustActiveTransitionType="Изменить тип активного перехода"
+AdvSceneSwitcher.transitionTab.transitionBehaviorSelectionError="Должна быть включена хотя бы одна опция:\n\n - Использовать переопределения переходов\n\n - Изменить тип активного перехода"
+AdvSceneSwitcher.transitionTab.transitionForAToB="Использовать переход для автоматического переключения сцены со сцены A на сцену B"
+AdvSceneSwitcher.transitionTab.transitionsHelp="<html><head/><body><p>Эти настройки <span style=\"font-style:italic;\">только</span> влияют на переходы, вызванные переключателем сцен - Проверьте <a href=\"https://obsproject.com/forum/resources/transition-table.1174/\"><span style=\" text-decoration: underline; color:#268bd2;\">Transition Table</span></a> если вы хотите настроить его для ручного изменения сцены.<br/>Настройки, определенные здесь, имеют приоритет над настройками перехода, сконфигурированными в других местах переключателя сцен.<br/><br/>Нажмите на символ плюса ниже, чтобы добавить новую запись.</p></body></html>"
+AdvSceneSwitcher.transitionTab.defaultTransition="Изменить переход, если сцена активна"
+AdvSceneSwitcher.transitionTab.entry="Переход от {{scenes}} к {{scenes2}} с помощью {{transitions}} с длительностью {{duration}}"
+AdvSceneSwitcher.transitionTab.defaultTransitionEntry="Когда сцена {{scenes}} активна, изменить переход сцены по умолчанию на {{transitions}}"
+AdvSceneSwitcher.transitionTab.defaultTransitionsHelp="Нажмите на символ плюса, чтобы добавить запись."
+AdvSceneSwitcher.transitionTab.defaultTransition.delay="Переключить переход {{defTransitionDelay}} после смены сцены."
+AdvSceneSwitcher.transitionTab.defaultTransition.delay.help="Задержка используется для того, чтобы избежать отмены переключения сцены, что может произойти, если тип перехода будет изменен, когда переход еще продолжается."
+
+; Pause Scenes Tab
+AdvSceneSwitcher.pauseTab.title="Пауза"
+AdvSceneSwitcher.pauseTab.pauseOnScene="Приостановить Scene Switcher на сцене"
+AdvSceneSwitcher.pauseTab.pauseInFocus1="Приостановить Scene Switcher когда "
+AdvSceneSwitcher.pauseTab.pauseInFocus2="находится в фокусе"
+AdvSceneSwitcher.pauseTab.pauseTypeScene="сцена активна"
+AdvSceneSwitcher.pauseTab.pauseTypeWindow="окно в фокусе"
+AdvSceneSwitcher.pauseTab.pauseTargetAll="все"
+AdvSceneSwitcher.pauseTab.pauseEntry="Пауза {{pauseTargets}} проверяет, когда {{pauseTypes}} {{scenes}} {{windows}}"
+AdvSceneSwitcher.pauseTab.help="На этой вкладке вы можете настроить приостановку отдельных методов переключения, если сцена активна или окно находится в фокусе.\n\nНажмите на выделенный символ плюса, чтобы продолжить."
+
+; 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="if fullscreen"
+AdvSceneSwitcher.windowTitleTab.maximized="if maximized"
+AdvSceneSwitcher.windowTitleTab.focused="if focused"
+AdvSceneSwitcher.windowTitleTab.entry="{{windows}} {{scenes}} {{transitions}} {{fullscreen}} {{maximized}} {{focused}}"
+AdvSceneSwitcher.windowTitleTab.windowsHelp="Переключение сцен на основе заголовков окон запущенных приложений.\nВы можете выбрать следующие дополнительные условия:\nОкно полноэкранное\nОкно максимизированное\nОкно сфокусированное\n\nНажмите на выделенный символ плюса, чтобы продолжить."
+AdvSceneSwitcher.windowTitleTab.ignoreWindowsHelp="Если заголовок окна игнорируется, переключатель сцен будет действовать так, как будто ранее выбранное окно все еще в фокусе.\nЭто позволит вам избежать переключения сцен, если вы часто переключаетесь на другое окно, которое не должно вызывать смену сцены.\n\nВыберите окно или введите заголовок окна выше и нажмите на символ плюса ниже, чтобы добавить его в список."
+
+; Executable Tab
+AdvSceneSwitcher.executableTab.title="Исполняемый"
+AdvSceneSwitcher.executableTab.implemented="Implemented by dasOven"
+AdvSceneSwitcher.executableTab.requiresFocus="только если сфокусирован"
+AdvSceneSwitcher.executableTab.entry="Когда {{processes}} запущены, переключить на {{scenes}} используя {{transitions}} {{requiresFocus}}"
+AdvSceneSwitcher.executableTab.help="Эта вкладка позволит вам автоматически переключаться между сценами, если запущен процесс.\nЭто может быть полезно в ситуациях, когда имя окна может измениться или неизвестно.\n\nНажмите на выделенный символ плюса, чтобы продолжить."
+
+; Screen Region Tab
+AdvSceneSwitcher.screenRegionTab.title="Регион"
+AdvSceneSwitcher.screenRegionTab.currentPosition="Курсор в данный момент находится в:"
+AdvSceneSwitcher.screenRegionTab.showGuideFrames="Показать направляющие кадры"
+AdvSceneSwitcher.screenRegionTab.hideGuideFrames="Скрыть направляющие рамки"
+AdvSceneSwitcher.screenRegionTab.excludeScenes.None="Нет выбора"
+AdvSceneSwitcher.screenRegionTab.entry="Если курсор находится в {{minX}} {{minY}} x {{maxX}} {{maxY}} переключить на {{scenes}} используя {{transitions}} если не указано {{excludeScenes}}"
+AdvSceneSwitcher.screenRegionTab.help="Эта вкладка позволит вам автоматически переключать сцены, основываясь на текущем положении курсора мыши.\n\nНажмите на выделенный символ плюса, чтобы продолжить."
+
+; Media Tab
+AdvSceneSwitcher.mediaTab.title="Медиа"
+AdvSceneSwitcher.mediaTab.implemented="Implemented by 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.playedToEnd="Воспроизведено до конца"
+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}} переключиться на {{scenes}} используя {{transitions}}"
+AdvSceneSwitcher.mediaTab.help="Эта вкладка позволит вам переключать сцены на основе состояний медиаисточников.\nНапример, вы можете автоматически переключиться на предыдущую сцену, когда выбранный медиаисточник закончил свое воспроизведение.\n\nНажмите на выделенный символ плюса, чтобы продолжить."
+
+; File Tab
+AdvSceneSwitcher.fileTab.title="Файл"
+AdvSceneSwitcher.fileTab.readWriteSceneFile="Считать / записать сцену из / в файл"
+AdvSceneSwitcher.fileTab.currentSceneOutputFile="Записать имя текущей сцены в этот файл:"
+AdvSceneSwitcher.fileTab.switchSceneBaseOnFile="Включить переключение сцен на основе ввода файла"
+AdvSceneSwitcher.fileTab.switchSceneNameInputFile="Считать имя сцены, на которую нужно переключиться, из этого файла:"
+AdvSceneSwitcher.fileTab.switchSceneBaseOnFileContent="Переключать сцену на основе содержимого файла"
+AdvSceneSwitcher.fileTab.remoteFileWarning="Обратите внимание, что при выборе опции remote переключатель сцен будет пытаться получить доступ к удаленному местоположению каждые x мс, как указано на вкладке Общие"
+AdvSceneSwitcher.fileTab.remoteFileWarning1="Обратите внимание, что переключатель сцены будет пытаться получить доступ к удаленному местоположению каждые  "
+AdvSceneSwitcher.fileTab.remoteFileWarning2="ms"
+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="Переключиться на {{scenes}} используя {{transitions}} если содержимое {{fileType}} {{filePath}} {{browseButton}} совпадает:"
+AdvSceneSwitcher.fileTab.entry2="{{matchText}}"
+AdvSceneSwitcher.fileTab.entry3="{{useRegex}} {{checkModificationDate}} {{checkFileContent}}"
+AdvSceneSwitcher.fileTab.help="Эта вкладка позволит вам автоматически переключать сцены на основе содержимого удаленных или локальных файлов.\n\nНажмите на выделенный символ плюса, чтобы продолжить."
+
+; Random Tab
+AdvSceneSwitcher.randomTab.title="Рандом"
+AdvSceneSwitcher.randomTab.randomDisabledWarning="Функциональность отключена - для активации выберите \"Если условие переключения не выполнено, переключиться на любую сцену на вкладке Random\" на вкладке Общие"
+AdvSceneSwitcher.randomTab.entry="Если условие переключения не выполнено, переключиться на {{scenes}} используя {{transitions}} для {{delay}}"
+AdvSceneSwitcher.randomTab.help="Переключатель сцен будет случайным образом выбирать запись на этой вкладке для переключения на заданное время.\nЗаметьте, что одна и та же запись не будет выбрана дважды подряд.\n\nНажмите на выделенный символ плюса, чтобы продолжить."
+
+; 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}} переключаются на {{scenes}} используя {{transitions}}"
+AdvSceneSwitcher.timeTab.help="Эта вкладка позволит вам автоматически переключаться на другую сцену на основе текущего местного времени.\n\nЗаметьте, что переключатель сцен будет переключаться только в точное время, которое вы указали.\nУбедитесь, что вы настроили параметры приоритета на вкладке Общие по своему вкусу, чтобы выбранная временная точка не была пропущена из-за других методов переключения, имеющих более высокий приоритет.\n\nНажмите на выделенный символ плюса, чтобы продолжить."
+
+; Idle Tab
+AdvSceneSwitcher.idleTab.title="Бездействие"
+AdvSceneSwitcher.idleTab.enable="Включить обнаружение простоя"
+AdvSceneSwitcher.idleTab.idleswitch="После {{duration}} отсутствия ввода с клавиатуры или мыши переключиться на сцену {{scenes}} используя {{transitions}}"
+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="Advanced Scene Switcher не удалось импортировать настройки!"
+AdvSceneSwitcher.sceneSequenceTab.loadSuccess="Настройки Advanced Scene Switcher импортированы успешно!"
+AdvSceneSwitcher.sceneSequenceTab.fileType="Текстовые файлы (*.txt)"
+AdvSceneSwitcher.sceneSequenceTab.interruptible="прервать"
+AdvSceneSwitcher.sceneSequenceTab.interruptibleHint="Другие методы переключения разрешены для прерывания этой последовательности сцен"
+AdvSceneSwitcher.sceneSequenceTab.entry="Когда {{startScenes}} активен, переключить на {{scenes}} после {{delay}} используя {{transitions}} {{interruptible}}"
+AdvSceneSwitcher.sceneSequenceTab.extendEdit="Расширить последовательность"
+AdvSceneSwitcher.sceneSequenceTab.extendEntry="После {{delay}} переключиться на {{scenes}} используя {{transitions}}"
+AdvSceneSwitcher.sceneSequenceTab.help="Эта вкладка позволит вам автоматически переключаться на другую сцену, если сцена была активна в течение заданного периода времени.\nНапример, вы можете автоматически переключаться между двумя сценами.\n\nНажмите на выделенный символ плюса, чтобы продолжить."
+
+; Audio Tab
+AdvSceneSwitcher.audioTab.title="Аудио"
+AdvSceneSwitcher.audioTab.condition.above="выше"
+AdvSceneSwitcher.audioTab.condition.below="ниже"
+AdvSceneSwitcher.audioTab.ignoreInactiveSource="если источник неактивен"
+AdvSceneSwitcher.audioTab.entry="Когда громкость {{audioSources}} равна {{condition}} {{volumeWidget}} в течение {{duration}} секунд переключить на {{scenes}}  используя {{transitions}} {{ignoreInactiveSource}}"
+AdvSceneSwitcher.audioTab.multiMatchfallbackCondition="Если несколько записей совпадают ..."
+AdvSceneSwitcher.audioTab.multiMatchfallback="... в течение {{duration}} секунд переключить на {{scenes}} используя {{transitions}}"
+AdvSceneSwitcher.audioTab.help="Эта вкладка позволит вам переключать сцены в зависимости от громкости источников.\nНапример, вы можете автоматически переключиться на другую сцену, если громкость вашего микрофона достигнет определенного порога.\n\nНажмите на выделенный символ плюса, чтобы продолжить."
+
+; Video Tab
+AdvSceneSwitcher.videoTab.title="Видео"
+AdvSceneSwitcher.videoTab.getScreenshot="Получить снимок экрана для выбранной записи"
+AdvSceneSwitcher.videoTab.getScreenshotHelp="Получить скриншот источника видео текущей выбранной записи и автоматически установить его в качестве целевого изображени"
+AdvSceneSwitcher.videoTab.condition.match="точно соответствует"
+AdvSceneSwitcher.videoTab.condition.match.tooltip="Точное совпадение требует, чтобы целевое и исходное изображение имели одинаковое разрешение.\nДаже каждый пиксель должен совпадать, поэтому не рекомендуется использовать форматы изображений, которые используют сжатие (например, .JPG)!"
+AdvSceneSwitcher.videoTab.condition.differ="не совпадает"
+AdvSceneSwitcher.videoTab.condition.hasNotChanged="не изменилось"
+AdvSceneSwitcher.videoTab.condition.hasChanged="изменилось"
+AdvSceneSwitcher.videoTab.ignoreInactiveSource="если источник неактивен"
+AdvSceneSwitcher.videoTab.entry="Когда {{videoSources}} {{condition}} {{filePath}} {{browseButton}} для {{duration}} переключиться на {{scenes}} используя {{transitions}} {{ignoreInactiveSource}}"
+AdvSceneSwitcher.videoTab.help="<html><head/><body><p>Эта вкладка позволит вам переключать сцены на основе текущего видеовыхода выбранных источников.<br/>Обязательно проверьте <a href=\"https://obsproject.com/forum/resources/pixel-match-switcher.1202/\"><span style=\" text-decoration: underline; color:#268bd2;\">Pixel Match Switcher</span></a> для еще лучшей реализации этой функциональности.<br/><br/> Нажмите на выделенный символ плюса, чтобы продолжить.</p></body></html>"
+
+; Network Tab
+AdvSceneSwitcher.networkTab.title="Сеть"
+AdvSceneSwitcher.networkTab.warning="Запуск сервера вне локальной сети позволит третьим лицам читать активную сцену."
+AdvSceneSwitcher.networkTab.DisabledWarning="ту функциональность, к сожалению, пришлось отключить на macOS из-за несовместимости библиотек при параллельном запуске плагина obs-websocket."
+AdvSceneSwitcher.networkTab.server="Запустить сервер (отправляет сообщения о переключении сцены всем подключенным клиентам)"
+AdvSceneSwitcher.networkTab.server.port="Порт"
+AdvSceneSwitcher.networkTab.server.lockToIPv4="Заблокировать сервер на использование только IPv4"
+AdvSceneSwitcher.networkTab.server.restrictSendToAutomatedSwitches="Отправлять сообщения только для автоматических переключателей сцен"
+AdvSceneSwitcher.networkTab.startFailed.message="Сервер WebSockets не удалось запустить, возможно потому, что:\n - TCP порт %1 может в настоящее время использоваться в другом месте в этой системе, возможно, другим приложением. Попробуйте установить другой TCP порт в настройках сервера WebSocket, или остановите любое приложение, которое может использовать этот порт.\n - Сообщение об ошибке: %2"
+AdvSceneSwitcher.networkTab.server.status.currentStatus="Текущий статус"
+AdvSceneSwitcher.networkTab.server.status.notRunning="Не запущен"
+AdvSceneSwitcher.networkTab.server.status.starting="Запуск"
+AdvSceneSwitcher.networkTab.server.status.running="Работает"
+AdvSceneSwitcher.networkTab.server.restart="Перезапустить сервер"
+AdvSceneSwitcher.networkTab.client="Запустить клиент (Получает сообщения о переключении сцен)"
+AdvSceneSwitcher.networkTab.client.address="Имя хоста или IP-адрес"
+AdvSceneSwitcher.networkTab.client.port="Порт"
+AdvSceneSwitcher.networkTab.client.status.currentStatus="Текущий статус"
+AdvSceneSwitcher.networkTab.client.status.disconnected="Отключено"
+AdvSceneSwitcher.networkTab.client.status.connecting="Подключение"
+AdvSceneSwitcher.networkTab.client.status.connected="Подключено"
+AdvSceneSwitcher.networkTab.client.reconnect="Принудительное переподключение"
+
+; Scene Group Tab
+AdvSceneSwitcher.sceneGroupTab.title="Группа сцен"
+AdvSceneSwitcher.sceneGroupTab.list="Группы сцен"
+AdvSceneSwitcher.sceneGroupTab.edit="Редактировать группы сцен"
+AdvSceneSwitcher.sceneGroupTab.edit.name="Имя:"
+AdvSceneSwitcher.sceneGroupTab.edit.type="Тип: {{type}}"
+AdvSceneSwitcher.sceneGroupTab.type.count="Количество"
+AdvSceneSwitcher.sceneGroupTab.type.time="Время"
+AdvSceneSwitcher.sceneGroupTab.type.random="Случайно"
+AdvSceneSwitcher.sceneGroupTab.edit.count="Переход к следующей сцене в списке после {{count}} совпадений"
+AdvSceneSwitcher.sceneGroupTab.edit.time="Переход к следующей сцене в списке по истечении {{time}}"
+AdvSceneSwitcher.sceneGroupTab.edit.random="Выбирать следующую сцену в списке случайным образом"
+AdvSceneSwitcher.sceneGroupTab.edit.repeat="Начинать с начала, если достигнут конец списка сцен"
+AdvSceneSwitcher.sceneGroupTab.edit.addScene="Добавить сцену"
+AdvSceneSwitcher.sceneGroupTab.add="Добавить группу сцен"
+AdvSceneSwitcher.sceneGroupTab.defaultname="Группа сцен %1"
+AdvSceneSwitcher.sceneGroupTab.exists="Группа сцен или название сцены уже существует"
+AdvSceneSwitcher.sceneGroupTab.help="Группы сцен могут быть выбраны в качестве цели так же, как и обычные сцены.\n\nКак следует из названия, группа сцен представляет собой набор из нескольких сцен.\nГруппа сцен будет продвигаться по списку назначенных ей сцен в зависимости от настроенных параметров, которые можно найти справа.\n\nВы можете настроить группу сцен на переход к следующей сцене в списке:\nПосле определенного количества раз, когда группа сцен выбрана в качестве цели.\nПо истечении определенного времени.\nИли случайным образом.\n\nНапример, группа сцен, содержащая сцены ...\nScene 1\nScene 2\nScene 3 \n... активирует \"Scene 1\" в первый раз, когда он выбран в качестве цели.\nВо второй раз он активируется \"Scene 2\".\nОставшееся время \"Scene 3\" будет активирован.\n\nНажмите на выделенный символ плюса ниже, чтобы добавить новую группу сцен."
+AdvSceneSwitcher.sceneGroupTab.scenes.help="Выберите группу сцен, которую вы хотите изменить слева.\n\nВыберите сцену для добавления в эту группу сцен, выбрав сцену выше и нажав на символ плюса ниже.\n\nСцена может быть добавлена несколько раз в одну и ту же группу сцен."
+
+; Scene Trigger Tab
+AdvSceneSwitcher.sceneTriggerTab.title="Триггеры сцены"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerType.none="--выбрать триггер--"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerType.sceneActive="активен"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerType.sceneInactive="не активен"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerType.sceneLeave="переключился с"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.none="--выбрать действие--"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.startRecording="начать запись"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.pauseRecording="приостановить запись"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.unpauseRecording="отменить паузу записи"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.stopRecording="остановить запись"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.stopStreaming="остановить потоковое вещание"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.startStreaming="начать потоковое вещание"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.startReplayBuffer="запустить буфер воспроизведения"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.stopReplayBuffer="остановить буфер воспроизведения"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.muteSource="отключить источник"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.unmuteSource="включить источник"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.startSwitcher="запустить переключатель сцены"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.stopSwitcher="остановить переключатель сцены"
+AdvSceneSwitcher.sceneTriggerTab.entry="Когда {{scenes}} {{triggers}} {{actions}} {{audioSources}} после {{duration}}"
+AdvSceneSwitcher.sceneTriggerTab.help="Эта вкладка позволяет запускать действия при изменении сцены, например, остановку записи или потоковой передачи."
+
+; Hotkey
+AdvSceneSwitcher.hotkey.startSwitcherHotkey="Запустить Advanced Scene Switcher"
+AdvSceneSwitcher.hotkey.stopSwitcherHotkey="становить Advanced Scene Switcher"
+AdvSceneSwitcher.hotkey.startStopToggleSwitcherHotkey="Переключить старт/стоп для Advanced Scene Switcher"
+
+AdvSceneSwitcher.askBackup="Обнаружена новая версия Advanced Scene Switcher.\nНужно ли создать резервную копию старых настроек?"
+
+AdvSceneSwitcher.close="Закрыть"
+AdvSceneSwitcher.browse="Обзор"
+
+AdvSceneSwitcher.selectScene="--выбрать сцену--"
+AdvSceneSwitcher.selectPreviousScene="Предыдущая сцена"
+AdvSceneSwitcher.currentTransition="Текущий переход"
+AdvSceneSwitcher.selectTransition="--выбрать переход--"
+AdvSceneSwitcher.selectWindow="--выбрать окно--"
+AdvSceneSwitcher.selectAudioSource="--выбрать источник звука--"
+AdvSceneSwitcher.selectVideoSource="--sвыбрать источник видео--"
+AdvSceneSwitcher.selectMediaSource="--выбрать источник мультимедиа--"
+AdvSceneSwitcher.selectProcess="--выбрать процесс--"
+AdvSceneSwitcher.enterPath="--ввести путь--"
+AdvSceneSwitcher.enterText="--ввести текст--"
+AdvSceneSwitcher.invaildEntriesWillNotBeSaved="недействительные записи не будут сохранены"
+AdvSceneSwitcher.selectWindowTip="Используйте \"OBS\" для указания окна OBS\nИспользуйте \"Переключение задач\"для указания ALT + TAB"
+
+AdvSceneSwitcher.status.active="Активный"
+AdvSceneSwitcher.status.inactive="Неактивен"
+
+AdvSceneSwitcher.unit.milliseconds="миллисекунды"
+AdvSceneSwitcher.unit.secends="секунды"
+AdvSceneSwitcher.unit.minutes="минуты"
+AdvSceneSwitcher.unit.hours="часы"

data/res/time.svg

@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" preserveAspectRatio="xMidYMid meet" viewBox="0 0 640 640" width="640" height="640"><defs><path d="M599.62 325.49C599.62 477.26 476.41 600.47 324.64 600.47C172.88 600.47 49.67 477.26 49.67 325.49C49.67 173.73 172.88 50.52 324.64 50.52C476.41 50.52 599.62 173.73 599.62 325.49Z" id="c3Wyq0kfYS"></path><mask id="maskanTyyngos" x="-20.33" y="-19.48" width="689.95" height="689.95" maskUnits="userSpaceOnUse"><rect x="-20.33" y="-19.48" width="689.95" height="689.95" fill="white"></rect><use xlink:href="#c3Wyq0kfYS" opacity="1" fill="black"></use></mask><path d="M334.97 96.07C339.51 96.07 343.2 99.75 343.2 104.3C343.2 151.24 343.2 283.84 343.2 330.78C343.2 335.32 339.51 339 334.97 339C329.2 339 320.09 339 314.31 339C309.77 339 306.09 335.32 306.09 330.78C306.09 283.84 306.09 151.24 306.09 104.3C306.09 99.75 309.77 96.07 314.31 96.07C320.09 96.07 329.2 96.07 334.97 96.07Z" id="fxMeu932c"></path><path d="M471.96 338.21C471.97 341.31 469.46 343.83 466.37 343.84C434.35 343.93 343.92 344.21 311.91 344.31C308.81 344.32 306.3 341.82 306.29 338.72C306.27 332.42 306.23 319.13 306.21 312.83C306.2 309.73 308.7 307.21 311.8 307.2C343.81 307.11 434.24 306.83 466.25 306.73C469.35 306.72 471.87 309.23 471.88 312.32C471.9 318.62 471.94 331.91 471.96 338.21Z" id="h65nGmP2BL"></path></defs><g><g><g><g mask="url(#maskanTyyngos)"><use xlink:href="#c3Wyq0kfYS" opacity="1" fill-opacity="0" stroke="#d2d2d2" stroke-width="70" stroke-opacity="1"></use></g></g><g><use xlink:href="#fxMeu932c" opacity="1" fill="#d2d2d2" fill-opacity="1"></use></g><g><use xlink:href="#h65nGmP2BL" opacity="1" fill="#d2d2d2" fill-opacity="1"></use></g></g></g></svg>

forms/advanced-scene-switcher.ui

@@ -693,13 +693,6 @@
               </property>
              </widget>
             </item>
-            <item>
-             <widget class="Line" name="line_4">
-              <property name="orientation">
-               <enum>Qt::Vertical</enum>
-              </property>
-             </widget>
-            </item>
             <item>
              <spacer name="horizontalSpacer_65">
               <property name="orientation">
@@ -723,7 +716,7 @@
          <property name="title">
           <string>AdvSceneSwitcher.macroTab.edit</string>
          </property>
-         <layout class="QVBoxLayout" name="verticalLayout_34" stretch="1,20,10">
+         <layout class="QVBoxLayout" name="verticalLayout_34">
           <item>
            <layout class="QHBoxLayout" name="horizontalLayout_18" stretch="0,0,0">
             <item>
@@ -752,184 +745,204 @@
            </layout>
           </item>
           <item>
-           <widget class="QScrollArea" name="macroConditions">
-            <property name="widgetResizable">
-             <bool>true</bool>
+           <widget class="QSplitter" name="splitter">
+            <property name="orientation">
+             <enum>Qt::Vertical</enum>
             </property>
-            <widget class="QWidget" name="scrollAreaWidgetContents_2">
-             <property name="geometry">
-              <rect>
-               <x>0</x>
-               <y>0</y>
-               <width>767</width>
-               <height>293</height>
-              </rect>
+            <widget class="QScrollArea" name="macroConditions">
+             <property name="widgetResizable">
+              <bool>true</bool>
              </property>
-             <layout class="QVBoxLayout" name="verticalLayout_35" stretch="10,1">
-              <item>
-               <layout class="QGridLayout" name="gridLayout_27">
-                <item row="0" column="0">
-                 <widget class="QLabel" name="macroEditConditionHelp">
-                  <property name="enabled">
-                   <bool>false</bool>
-                  </property>
-                  <property name="text">
-                   <string>AdvSceneSwitcher.macroTab.editConditionHelp</string>
-                  </property>
-                  <property name="alignment">
-                   <set>Qt::AlignCenter</set>
-                  </property>
-                  <property name="wordWrap">
-                   <bool>true</bool>
-                  </property>
-                 </widget>
-                </item>
-                <item row="0" column="0">
-                 <layout class="QVBoxLayout" name="macroEditConditionLayout"/>
-                </item>
-               </layout>
-              </item>
-              <item>
-               <layout class="QHBoxLayout" name="horizontalLayout_12">
-                <item>
-                 <widget class="QPushButton" name="conditionAdd">
-                  <property name="maximumSize">
-                   <size>
-                    <width>22</width>
-                    <height>22</height>
-                   </size>
-                  </property>
-                  <property name="flat">
-                   <bool>true</bool>
-                  </property>
-                  <property name="themeID" stdset="0">
-                   <string notr="true">addIconSmall</string>
-                  </property>
-                 </widget>
-                </item>
-                <item>
-                 <widget class="QPushButton" name="conditionRemove">
-                  <property name="maximumSize">
-                   <size>
-                    <width>22</width>
-                    <height>22</height>
-                   </size>
-                  </property>
-                  <property name="flat">
-                   <bool>true</bool>
-                  </property>
-                  <property name="themeID" stdset="0">
-                   <string notr="true">removeIconSmall</string>
-                  </property>
-                 </widget>
-                </item>
-                <item>
-                 <spacer name="horizontalSpacer_15">
-                  <property name="orientation">
-                   <enum>Qt::Horizontal</enum>
-                  </property>
-                  <property name="sizeHint" stdset="0">
-                   <size>
-                    <width>40</width>
-                    <height>20</height>
-                   </size>
-                  </property>
-                 </spacer>
-                </item>
-               </layout>
-              </item>
-             </layout>
+             <widget class="QWidget" name="scrollAreaWidgetContents_2">
+              <property name="geometry">
+               <rect>
+                <x>0</x>
+                <y>0</y>
+                <width>767</width>
+                <height>220</height>
+               </rect>
+              </property>
+              <layout class="QVBoxLayout" name="verticalLayout_35" stretch="10,1">
+               <property name="sizeConstraint">
+                <enum>QLayout::SetMinAndMaxSize</enum>
+               </property>
+               <item>
+                <layout class="QGridLayout" name="gridLayout_27">
+                 <property name="sizeConstraint">
+                  <enum>QLayout::SetMinAndMaxSize</enum>
+                 </property>
+                 <item row="0" column="0">
+                  <widget class="QLabel" name="macroEditConditionHelp">
+                   <property name="enabled">
+                    <bool>false</bool>
+                   </property>
+                   <property name="text">
+                    <string>AdvSceneSwitcher.macroTab.editConditionHelp</string>
+                   </property>
+                   <property name="alignment">
+                    <set>Qt::AlignCenter</set>
+                   </property>
+                   <property name="wordWrap">
+                    <bool>true</bool>
+                   </property>
+                  </widget>
+                 </item>
+                 <item row="0" column="0">
+                  <layout class="QVBoxLayout" name="macroEditConditionLayout">
+                   <property name="sizeConstraint">
+                    <enum>QLayout::SetFixedSize</enum>
+                   </property>
+                  </layout>
+                 </item>
+                </layout>
+               </item>
+               <item>
+                <layout class="QHBoxLayout" name="horizontalLayout_12">
+                 <item>
+                  <widget class="QPushButton" name="conditionAdd">
+                   <property name="maximumSize">
+                    <size>
+                     <width>22</width>
+                     <height>22</height>
+                    </size>
+                   </property>
+                   <property name="flat">
+                    <bool>true</bool>
+                   </property>
+                   <property name="themeID" stdset="0">
+                    <string notr="true">addIconSmall</string>
+                   </property>
+                  </widget>
+                 </item>
+                 <item>
+                  <widget class="QPushButton" name="conditionRemove">
+                   <property name="maximumSize">
+                    <size>
+                     <width>22</width>
+                     <height>22</height>
+                    </size>
+                   </property>
+                   <property name="flat">
+                    <bool>true</bool>
+                   </property>
+                   <property name="themeID" stdset="0">
+                    <string notr="true">removeIconSmall</string>
+                   </property>
+                  </widget>
+                 </item>
+                 <item>
+                  <spacer name="horizontalSpacer_15">
+                   <property name="orientation">
+                    <enum>Qt::Horizontal</enum>
+                   </property>
+                   <property name="sizeHint" stdset="0">
+                    <size>
+                     <width>40</width>
+                     <height>20</height>
+                    </size>
+                   </property>
+                  </spacer>
+                 </item>
+                </layout>
+               </item>
+              </layout>
+             </widget>
             </widget>
-           </widget>
-          </item>
-          <item>
-           <widget class="QScrollArea" name="macroActions">
-            <property name="widgetResizable">
-             <bool>true</bool>
-            </property>
-            <widget class="QWidget" name="scrollAreaWidgetContents_3">
-             <property name="geometry">
-              <rect>
-               <x>0</x>
-               <y>0</y>
-               <width>767</width>
-               <height>145</height>
-              </rect>
+            <widget class="QScrollArea" name="macroActions">
+             <property name="widgetResizable">
+              <bool>true</bool>
              </property>
-             <layout class="QVBoxLayout" name="verticalLayout_33" stretch="10,1">
-              <item>
-               <layout class="QGridLayout" name="gridLayout_25">
-                <item row="0" column="0">
-                 <widget class="QLabel" name="macroEditActionHelp">
-                  <property name="enabled">
-                   <bool>false</bool>
-                  </property>
-                  <property name="text">
-                   <string>AdvSceneSwitcher.macroTab.editActionHelp</string>
-                  </property>
-                  <property name="alignment">
-                   <set>Qt::AlignCenter</set>
-                  </property>
-                  <property name="wordWrap">
-                   <bool>true</bool>
-                  </property>
-                 </widget>
-                </item>
-                <item row="0" column="0">
-                 <layout class="QVBoxLayout" name="macroEditActionLayout"/>
-                </item>
-               </layout>
-              </item>
-              <item>
-               <layout class="QHBoxLayout" name="horizontalLayout_21">
-                <item>
-                 <widget class="QPushButton" name="actionAdd">
-                  <property name="maximumSize">
-                   <size>
-                    <width>22</width>
-                    <height>22</height>
-                   </size>
-                  </property>
-                  <property name="flat">
-                   <bool>true</bool>
-                  </property>
-                  <property name="themeID" stdset="0">
-                   <string notr="true">addIconSmall</string>
-                  </property>
-                 </widget>
-                </item>
-                <item>
-                 <widget class="QPushButton" name="actionRemove">
-                  <property name="maximumSize">
-                   <size>
-                    <width>22</width>
-                    <height>22</height>
-                   </size>
-                  </property>
-                  <property name="flat">
-                   <bool>true</bool>
-                  </property>
-                  <property name="themeID" stdset="0">
-                   <string notr="true">removeIconSmall</string>
-                  </property>
-                 </widget>
-                </item>
-                <item>
-                 <spacer name="horizontalSpacer_14">
-                  <property name="orientation">
-                   <enum>Qt::Horizontal</enum>
-                  </property>
-                  <property name="sizeHint" stdset="0">
-                   <size>
-                    <width>40</width>
-                    <height>20</height>
-                   </size>
-                  </property>
-                 </spacer>
-                </item>
-               </layout>
-              </item>
-             </layout>
+             <widget class="QWidget" name="scrollAreaWidgetContents_3">
+              <property name="geometry">
+               <rect>
+                <x>0</x>
+                <y>0</y>
+                <width>767</width>
+                <height>219</height>
+               </rect>
+              </property>
+              <layout class="QVBoxLayout" name="verticalLayout_33" stretch="10,1">
+               <property name="sizeConstraint">
+                <enum>QLayout::SetMinAndMaxSize</enum>
+               </property>
+               <item>
+                <layout class="QGridLayout" name="gridLayout_25">
+                 <item row="0" column="0">
+                  <widget class="QLabel" name="macroEditActionHelp">
+                   <property name="enabled">
+                    <bool>false</bool>
+                   </property>
+                   <property name="text">
+                    <string>AdvSceneSwitcher.macroTab.editActionHelp</string>
+                   </property>
+                   <property name="alignment">
+                    <set>Qt::AlignCenter</set>
+                   </property>
+                   <property name="wordWrap">
+                    <bool>true</bool>
+                   </property>
+                  </widget>
+                 </item>
+                 <item row="0" column="0">
+                  <layout class="QVBoxLayout" name="macroEditActionLayout">
+                   <property name="sizeConstraint">
+                    <enum>QLayout::SetMinAndMaxSize</enum>
+                   </property>
+                  </layout>
+                 </item>
+                </layout>
+               </item>
+               <item>
+                <layout class="QHBoxLayout" name="horizontalLayout_21">
+                 <item>
+                  <widget class="QPushButton" name="actionAdd">
+                   <property name="maximumSize">
+                    <size>
+                     <width>22</width>
+                     <height>22</height>
+                    </size>
+                   </property>
+                   <property name="flat">
+                    <bool>true</bool>
+                   </property>
+                   <property name="themeID" stdset="0">
+                    <string notr="true">addIconSmall</string>
+                   </property>
+                  </widget>
+                 </item>
+                 <item>
+                  <widget class="QPushButton" name="actionRemove">
+                   <property name="maximumSize">
+                    <size>
+                     <width>22</width>
+                     <height>22</height>
+                    </size>
+                   </property>
+                   <property name="flat">
+                    <bool>true</bool>
+                   </property>
+                   <property name="themeID" stdset="0">
+                    <string notr="true">removeIconSmall</string>
+                   </property>
+                  </widget>
+                 </item>
+                 <item>
+                  <spacer name="horizontalSpacer_14">
+                   <property name="orientation">
+                    <enum>Qt::Horizontal</enum>
+                   </property>
+                   <property name="sizeHint" stdset="0">
+                    <size>
+                     <width>40</width>
+                     <height>20</height>
+                    </size>
+                   </property>
+                  </spacer>
+                 </item>
+                </layout>
+               </item>
+              </layout>
+             </widget>
             </widget>
            </widget>
           </item>
@@ -3703,6 +3716,13 @@
        <string>AdvSceneSwitcher.networkTab.title</string>
       </attribute>
       <layout class="QVBoxLayout" name="verticalLayout_30">
+       <item>
+        <widget class="QLabel" name="networkTabDescription">
+         <property name="text">
+          <string>AdvSceneSwitcher.networkTab.description</string>
+         </property>
+        </widget>
+       </item>
        <item>
         <widget class="QLabel" name="networkTabWarningLabel">
          <property name="text">
@@ -3724,6 +3744,27 @@
          <layout class="QVBoxLayout" name="verticalLayout_31">
           <item>
            <layout class="QGridLayout" name="gridLayout_24">
+            <item row="3" column="1">
+             <widget class="QCheckBox" name="restrictSend">
+              <property name="text">
+               <string>AdvSceneSwitcher.networkTab.server.restrictSendToAutomatedSwitches</string>
+              </property>
+             </widget>
+            </item>
+            <item row="5" column="0">
+             <widget class="QLabel" name="label_19">
+              <property name="text">
+               <string>AdvSceneSwitcher.networkTab.server.status.currentStatus</string>
+              </property>
+             </widget>
+            </item>
+            <item row="5" column="1">
+             <widget class="QLabel" name="serverStatus">
+              <property name="text">
+               <string>AdvSceneSwitcher.networkTab.server.status.notRunning</string>
+              </property>
+             </widget>
+            </item>
             <item row="0" column="1">
              <widget class="QSpinBox" name="serverPort">
               <property name="minimum">
@@ -3751,24 +3792,17 @@
               </property>
              </widget>
             </item>
-            <item row="3" column="0">
-             <widget class="QLabel" name="label_19">
+            <item row="4" column="1">
+             <widget class="QCheckBox" name="sendPreview">
               <property name="text">
-               <string>AdvSceneSwitcher.networkTab.server.status.currentStatus</string>
-              </property>
-             </widget>
-            </item>
-            <item row="3" column="1">
-             <widget class="QLabel" name="serverStatus">
-              <property name="text">
-               <string>AdvSceneSwitcher.networkTab.server.status.notRunning</string>
+               <string>AdvSceneSwitcher.networkTab.server.sendPreview</string>
               </property>
              </widget>
             </item>
             <item row="2" column="1">
-             <widget class="QCheckBox" name="restrictSend">
+             <widget class="QCheckBox" name="sendSceneChange">
               <property name="text">
-               <string>AdvSceneSwitcher.networkTab.server.restrictSendToAutomatedSwitches</string>
+               <string>AdvSceneSwitcher.networkTab.server.sendSceneChange</string>
               </property>
              </widget>
             </item>

src/advanced-scene-switcher.cpp

@@ -1,13 +1,10 @@
 #include <QMainWindow>
 #include <QAction>
-#include <QtGui/qstandarditemmodel.h>
-#include <QPropertyAnimation>
-#include <QGraphicsColorizeEffect>
-#include <QMessageBox>
+#include <QFileDialog>
+#include <regex>
 
 #include <obs-module.h>
 #include <obs-frontend-api.h>
-#include <util/util.hpp>
 
 #include "headers/advanced-scene-switcher.hpp"
 #include "headers/curl-helper.hpp"
@@ -73,331 +70,36 @@ void AdvSceneSwitcher::loadUI()
 }
 
 /******************************************************************************
- * UI helpers
+ * Saving and loading
  ******************************************************************************/
-void AdvSceneSwitcher::addSelectionEntry(QComboBox *sel,
-					 const char *description,
-					 bool selectable, const char *tooltip)
+void AskBackup(obs_data_t *obj)
 {
-	sel->addItem(description);
+	bool backupSettings = DisplayMessage(
+		obs_module_text("AdvSceneSwitcher.askBackup"), true);
 
-	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);
-	if (!selectable) {
-		firstItem->setSelectable(false);
-		firstItem->setEnabled(false);
-	}
-}
-
-void AdvSceneSwitcher::populateSceneSelection(QComboBox *sel, bool addPrevious,
-					      bool addSceneGroup,
-					      bool addSelect,
-					      std::string selectText,
-					      bool selectable)
-{
-	if (addSelect) {
-		if (selectText.empty()) {
-			addSelectionEntry(
-				sel,
-				obs_module_text("AdvSceneSwitcher.selectScene"),
-				selectable,
-				obs_module_text(
-					"AdvSceneSwitcher.invaildEntriesWillNotBeSaved"));
-		} else {
-			addSelectionEntry(sel, selectText.c_str(), selectable);
-		}
-	}
-
-	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 addCurrent,
-						   bool addSelect,
-						   bool selectable)
-{
-	if (addSelect) {
-		addSelectionEntry(
-			sel,
-			obs_module_text("AdvSceneSwitcher.selectTransition"),
-			selectable);
-	}
-
-	if (addCurrent) {
-		sel->addItem(
-			obs_module_text("AdvSceneSwitcher.currentTransition"));
-	}
-
-	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"),
-			false,
-			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::populateVideoSelection(QComboBox *sel, bool addScenes,
-					      bool addSelect)
-{
-	if (addSelect) {
-		addSelectionEntry(
-			sel,
-			obs_module_text("AdvSceneSwitcher.selectVideoSource"),
-			false,
-			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);
-		std::string test = obs_source_get_name(source);
-		if ((flags & (OBS_SOURCE_VIDEO | OBS_SOURCE_ASYNC)) != 0) {
-			list->push_back(obs_source_get_name(source));
-		}
-		return true;
-	};
-
-	std::vector<std::string> videoSources;
-	obs_enum_sources(sourceEnum, &videoSources);
-	sort(videoSources.begin(), videoSources.end());
-	for (std::string &source : videoSources) {
-		sel->addItem(source.c_str());
-	}
-
-	if (addScenes) {
-		populateSceneSelection(sel, false, false, false);
-	}
-}
-
-void AdvSceneSwitcher::populateMediaSelection(QComboBox *sel, bool addSelect)
-{
-	if (addSelect) {
-		addSelectionEntry(
-			sel,
-			obs_module_text("AdvSceneSwitcher.selectMediaSource"),
-			false,
-			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");
+	if (!backupSettings) {
 		return;
 	}
 
-	if (addButton && addHighlight) {
-		addButton->disconnect(*addHighlight);
+	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;
 	}
 
-	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;
+	QFile file(directory);
+	if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
+		return;
 	}
 
-	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;
+	obs_data_save_json(obj, file.fileName().toUtf8().constData());
 }
 
-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) {
@@ -422,7 +124,7 @@ static void SaveSceneSwitcher(obs_data_t *save_data, bool saving, void *)
 			obj = obs_data_create();
 		}
 		if (switcher->versionChanged(obj, g_GIT_SHA1)) {
-			AdvSceneSwitcher::AskBackup(obj);
+			AskBackup(obj);
 		}
 
 		switcher->loadSettings(obj);
@@ -484,6 +186,7 @@ void SwitcherData::Thread()
 		}
 
 		vblog(LOG_INFO, "try to sleep for %ld", duration.count());
+		setWaitScene();
 		cv.wait_for(lock, duration);
 
 		startTime = std::chrono::high_resolution_clock::now();
@@ -497,6 +200,7 @@ void SwitcherData::Thread()
 		if (checkPause()) {
 			continue;
 		}
+		setPreconditions();
 		match = checkForMatch(scene, transition, linger,
 				      setPrevSceneAfterLinger, macroMatch);
 		if (stop) {
@@ -510,6 +214,7 @@ void SwitcherData::Thread()
 			vblog(LOG_INFO, "sleep for %ld before switching scene",
 			      duration.count());
 
+			setWaitScene();
 			cv.wait_for(lock, duration);
 
 			if (stop) {
@@ -549,6 +254,37 @@ void SwitcherData::Thread()
 	blog(LOG_INFO, "stopped");
 }
 
+void SwitcherData::setPreconditions()
+{
+	// Window title
+	lastTitle = currentTitle;
+	std::string title;
+	GetCurrentWindowTitle(title);
+	for (auto &window : ignoreWindowsSwitches) {
+		bool equals = (title == window);
+		bool matches = false;
+		if (!equals) {
+			try {
+				std::regex expr(window);
+				matches = std::regex_match(title, expr);
+
+			} catch (const std::regex_error &) {
+			}
+		}
+		if (equals || matches) {
+			title = lastTitle;
+			break;
+		}
+	}
+	currentTitle = title;
+
+	// Cursor
+	std::pair<int, int> cursorPos = getCursorPos();
+	cursorPosChanged = cursorPos.first != switcher->lastCursorPos.first ||
+			   cursorPos.second != switcher->lastCursorPos.second;
+	lastCursorPos = getCursorPos();
+}
+
 bool SwitcherData::checkForMatch(OBSWeakSource &scene,
 				 OBSWeakSource &transition, int &linger,
 				 bool &setPrevSceneAfterLinger,
@@ -616,7 +352,7 @@ bool SwitcherData::checkForMatch(OBSWeakSource &scene,
 	return match;
 }
 
-void switchScene(sceneSwitchInfo sceneSwitch)
+void switchScene(const sceneSwitchInfo &sceneSwitch)
 {
 	if (!sceneSwitch.scene && switcher->verbose) {
 		blog(LOG_INFO, "nothing to switch to");
@@ -624,7 +360,8 @@ void switchScene(sceneSwitchInfo sceneSwitch)
 	}
 
 	obs_source_t *source = obs_weak_source_get_source(sceneSwitch.scene);
-	obs_source_t *currentSource = obs_frontend_get_current_scene();
+	obs_source_t *currentSource =
+		obs_weak_source_get_source(switcher->currentScene);
 
 	if (source && source != currentSource) {
 		transitionData currentTransitionData;
@@ -640,7 +377,7 @@ void switchScene(sceneSwitchInfo sceneSwitch)
 			blog(LOG_INFO, "switched scene");
 		}
 
-		if (switcher->networkConfig.ServerEnabled) {
+		if (switcher->networkConfig.ShouldSendSceneChange()) {
 			switcher->server.sendMessage(sceneSwitch);
 		}
 	}
@@ -648,6 +385,13 @@ void switchScene(sceneSwitchInfo sceneSwitch)
 	obs_source_release(source);
 }
 
+void switchPreviewScene(const OBSWeakSource &ws)
+{
+	auto source = obs_weak_source_get_source(ws);
+	obs_frontend_set_current_preview_scene(source);
+	obs_source_release(source);
+}
+
 void SwitcherData::Start()
 {
 	if (!(th && th->isRunning())) {
@@ -669,23 +413,38 @@ void SwitcherData::Start()
 	}
 }
 
+void ResetMacroCounters()
+{
+	for (auto &m : switcher->macros) {
+		m.ResetCount();
+	}
+}
+
 void SwitcherData::Stop()
 {
 	if (th && th->isRunning()) {
 		stop = true;
-		transitionCv.notify_one();
 		cv.notify_one();
+		abortMacroWait = true;
+		macroWaitCv.notify_one();
 		th->wait();
 		delete th;
 		th = nullptr;
 
 		writeToStatusFile("Advanced Scene Switcher stopped");
+		ResetMacroCounters();
 	}
 
 	server.stop();
 	client.disconnect();
 }
 
+void SwitcherData::setWaitScene()
+{
+	waitScene = obs_frontend_get_current_scene();
+	obs_source_release(waitScene);
+}
+
 bool SwitcherData::sceneChangedDuringWait()
 {
 	obs_source_t *currentSource = obs_frontend_get_current_scene();
@@ -709,58 +468,81 @@ extern "C" void FreeSceneSwitcher()
 		loaded_curl_lib = nullptr;
 	}
 
+	PlatformCleanup();
+
 	delete switcher;
 	switcher = nullptr;
 }
 
-void handleSceneChange(SwitcherData *s)
+void handleSceneChange()
 {
 	// Stop waiting if scene was changed
-	if (s->sceneChangedDuringWait()) {
-		s->cv.notify_one();
+	if (switcher->sceneChangedDuringWait()) {
+		switcher->cv.notify_one();
 	}
 
-	// Set previous scene
+	// Set current and 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->previousSceneHelper != ws) {
-		s->previousScene = s->previousSceneHelper;
-		s->previousSceneHelper = ws;
+
+	if (ws && ws != switcher->currentScene) {
+		switcher->previousScene = switcher->currentScene;
+		switcher->currentScene = ws;
+		vblog(LOG_INFO, "current scene:  %s",
+		      GetWeakSourceName(switcher->currentScene).c_str());
+		vblog(LOG_INFO, "previous scene: %s",
+		      GetWeakSourceName(switcher->previousScene).c_str());
 	}
 
-	s->checkTriggers();
-	s->checkDefaultSceneTransitions();
+	obs_source_release(source);
+	obs_weak_source_release(ws);
 
-	if (switcher->networkConfig.ServerEnabled &&
-	    switcher->networkConfig.SendAll) {
+	switcher->checkTriggers();
+	switcher->checkDefaultSceneTransitions();
+
+	if (switcher->networkConfig.ShouldSendFrontendSceneChange()) {
 		switcher->server.sendMessage({ws, nullptr, 0});
 	}
 }
 
-void setLiveTime(SwitcherData *s)
+void setLiveTime()
 {
-	s->liveTime = QDateTime::currentDateTime();
+	switcher->liveTime = QDateTime::currentDateTime();
 }
 
-void resetLiveTime(SwitcherData *s)
+void resetLiveTime()
 {
-	s->liveTime = QDateTime();
+	switcher->liveTime = QDateTime();
 }
 
-void checkAutoStartRecording(SwitcherData *s)
+void checkAutoStartRecording()
 {
-	if (s->autoStartEvent == AutoStartEvent::RECORDING ||
-	    s->autoStartEvent == AutoStartEvent::RECORINDG_OR_STREAMING)
-		s->Start();
+	if (switcher->autoStartEvent == AutoStartEvent::RECORDING ||
+	    switcher->autoStartEvent == AutoStartEvent::RECORINDG_OR_STREAMING)
+		switcher->Start();
 }
 
-void checkAutoStartStreaming(SwitcherData *s)
+void checkAutoStartStreaming()
 {
-	if (s->autoStartEvent == AutoStartEvent::STREAMING ||
-	    s->autoStartEvent == AutoStartEvent::RECORINDG_OR_STREAMING)
-		s->Start();
+	if (switcher->autoStartEvent == AutoStartEvent::STREAMING ||
+	    switcher->autoStartEvent == AutoStartEvent::RECORINDG_OR_STREAMING)
+		switcher->Start();
+}
+
+void handlePeviewSceneChange()
+{
+	if (switcher->networkConfig.ShouldSendPrviewSceneChange()) {
+		auto source = obs_frontend_get_current_preview_scene();
+		auto weak = obs_source_get_weak_source(source);
+		switcher->server.sendMessage({weak, nullptr, 0}, true);
+		obs_weak_source_release(weak);
+		obs_source_release(source);
+	}
+}
+
+void setReplayBufferSaved()
+{
+	switcher->replayBufferSaved = true;
 }
 
 // Note to future self:
@@ -768,24 +550,34 @@ void checkAutoStartStreaming(SwitcherData *s)
 // frontend functions such as obs_frontend_set_current_scene()
 static void OBSEvent(enum obs_frontend_event event, void *switcher)
 {
+	if (!switcher) {
+		return;
+	}
+
 	switch (event) {
 	case OBS_FRONTEND_EVENT_EXIT:
 		FreeSceneSwitcher();
 		break;
 	case OBS_FRONTEND_EVENT_SCENE_CHANGED:
-		handleSceneChange((SwitcherData *)switcher);
+		handleSceneChange();
+		break;
+	case OBS_FRONTEND_EVENT_PREVIEW_SCENE_CHANGED:
+		handlePeviewSceneChange();
 		break;
 	case OBS_FRONTEND_EVENT_RECORDING_STARTED:
-		setLiveTime((SwitcherData *)switcher);
-		checkAutoStartRecording((SwitcherData *)switcher);
+		setLiveTime();
+		checkAutoStartRecording();
 		break;
 	case OBS_FRONTEND_EVENT_STREAMING_STARTED:
-		setLiveTime((SwitcherData *)switcher);
-		checkAutoStartStreaming((SwitcherData *)switcher);
+		setLiveTime();
+		checkAutoStartStreaming();
 		break;
 	case OBS_FRONTEND_EVENT_RECORDING_STOPPED:
 	case OBS_FRONTEND_EVENT_STREAMING_STOPPED:
-		resetLiveTime((SwitcherData *)switcher);
+		resetLiveTime();
+		break;
+	case OBS_FRONTEND_EVENT_REPLAY_BUFFER_SAVED:
+		setReplayBufferSaved();
 		break;
 	default:
 		break;
@@ -805,6 +597,8 @@ extern "C" void InitSceneSwitcher()
 		switcher->curl = f_curl_init();
 	}
 
+	PlatformInit();
+
 	auto cb = []() {
 		QMainWindow *window =
 			(QMainWindow *)obs_frontend_get_main_window();

src/curl-helper.cpp

@@ -33,6 +33,17 @@ bool resolveCurl()
 
 bool loadCurl()
 {
+	loaded_curl_lib = new QLibrary(curl_library_name, nullptr);
+	if (resolveCurl()) {
+		blog(LOG_INFO, "[adv-ss] found curl library");
+		return true;
+	} else {
+		delete loaded_curl_lib;
+		loaded_curl_lib = nullptr;
+		blog(LOG_WARNING,
+		     "[adv-ss] couldn't find the curl library in PATH");
+	}
+
 	QStringList locations;
 	locations << QDir::currentPath();
 #if defined(__linux__) || defined(__APPLE__)

src/duration-control.cpp

@@ -1,4 +1,5 @@
 #include "headers/duration-control.hpp"
+#include "headers/utility.hpp"
 #include "obs-module.h"
 
 #include <sstream>
@@ -31,6 +32,20 @@ bool Duration::DurationReached()
 	return runTime.count() >= seconds * 1000;
 }
 
+double Duration::TimeRemaining()
+{
+	if (_startTime.time_since_epoch().count() == 0) {
+		return seconds;
+	}
+	auto runTime = std::chrono::duration_cast<std::chrono::milliseconds>(
+		std::chrono::high_resolution_clock::now() - _startTime);
+
+	if (runTime.count() >= seconds * 1000) {
+		return 0;
+	}
+	return (seconds * 1000 - runTime.count()) / 1000.;
+}
+
 void Duration::Reset()
 {
 	_startTime = {};
@@ -99,6 +114,8 @@ DurationSelection::DurationSelection(QWidget *parent, bool showUnitSelection)
 			 SLOT(_UnitChanged(int)));
 
 	QHBoxLayout *layout = new QHBoxLayout;
+	layout->setContentsMargins(0, 0, 0, 0);
+	layout->setSpacing(11);
 	layout->addWidget(_duration);
 	if (showUnitSelection) {
 		layout->addWidget(_unitSelection);
@@ -137,3 +154,131 @@ void DurationSelection::_UnitChanged(int idx)
 
 	emit UnitChanged(unit);
 }
+
+void DurationConstraint::Save(obs_data_t *obj, const char *condName,
+			      const char *secondsName, const char *unitName)
+{
+	obs_data_set_int(obj, condName, static_cast<int>(_type));
+	_dur.Save(obj, secondsName, unitName);
+}
+
+void DurationConstraint::Load(obs_data_t *obj, const char *condName,
+			      const char *secondsName, const char *unitName)
+{
+	// For backwards compatability check if duration value exist without
+	// time constraint condition - if so assume DurationCondition::MORE
+	if (!obs_data_has_user_value(obj, condName) &&
+	    obs_data_has_user_value(obj, secondsName)) {
+		obs_data_set_int(obj, condName,
+				 static_cast<int>(DurationCondition::MORE));
+	}
+
+	_type = static_cast<DurationCondition>(obs_data_get_int(obj, condName));
+	_dur.Load(obj, secondsName, unitName);
+}
+
+bool DurationConstraint::DurationReached()
+{
+	switch (_type) {
+	case DurationCondition::NONE:
+		return true;
+		break;
+	case DurationCondition::MORE:
+		return _dur.DurationReached();
+		break;
+	case DurationCondition::EQUAL:
+		if (_dur.DurationReached() && !_timeReached) {
+			_timeReached = true;
+			return true;
+		}
+		break;
+	case DurationCondition::LESS:
+		return !_dur.DurationReached();
+		break;
+	default:
+		break;
+	}
+	return false;
+}
+
+void DurationConstraint::Reset()
+{
+	_timeReached = false;
+	_dur.Reset();
+}
+
+static void populateConditions(QComboBox *list)
+{
+	list->addItem(
+		obs_module_text("AdvSceneSwitcher.duration.condition.none"));
+	list->addItem(
+		obs_module_text("AdvSceneSwitcher.duration.condition.more"));
+	list->addItem(
+		obs_module_text("AdvSceneSwitcher.duration.condition.equal"));
+	list->addItem(
+		obs_module_text("AdvSceneSwitcher.duration.condition.less"));
+}
+
+DurationConstraintEdit::DurationConstraintEdit(QWidget *parent)
+{
+	_condition = new QComboBox(parent);
+	_duration = new DurationSelection(parent);
+	_toggle = new QPushButton(parent);
+	_toggle->setMaximumSize(22, 22);
+	_toggle->setIcon(
+		QIcon(QString::fromStdString(getDataFilePath("res/time.svg"))));
+	populateConditions(_condition);
+	QWidget::connect(_condition, SIGNAL(currentIndexChanged(int)), this,
+			 SLOT(_ConditionChanged(int)));
+	QObject::connect(_duration, &DurationSelection::DurationChanged, this,
+			 &DurationConstraintEdit::DurationChanged);
+	QObject::connect(_duration, &DurationSelection::UnitChanged, this,
+			 &DurationConstraintEdit::UnitChanged);
+	QWidget::connect(_toggle, SIGNAL(clicked()), this,
+			 SLOT(ToggleClicked()));
+
+	QHBoxLayout *layout = new QHBoxLayout;
+	layout->setContentsMargins(0, 0, 0, 0);
+	layout->setSpacing(11);
+	layout->addWidget(_toggle);
+	layout->addWidget(_condition);
+	layout->addWidget(_duration);
+	setLayout(layout);
+	Collapse(true);
+}
+
+void DurationConstraintEdit::SetValue(DurationConstraint &value)
+{
+	_duration->SetDuration(value.GetDuration());
+	_condition->setCurrentIndex(static_cast<int>(value.GetCondition()));
+	_duration->setVisible(value.GetCondition() != DurationCondition::NONE);
+}
+
+void DurationConstraintEdit::SetUnit(DurationUnit u)
+{
+	_duration->SetUnit(u);
+}
+
+void DurationConstraintEdit::SetDuration(const Duration &d)
+{
+	_duration->SetDuration(d);
+}
+
+void DurationConstraintEdit::_ConditionChanged(int value)
+{
+	auto cond = static_cast<DurationCondition>(value);
+	Collapse(cond == DurationCondition::NONE);
+	emit ConditionChanged(cond);
+}
+
+void DurationConstraintEdit::ToggleClicked()
+{
+	Collapse(false);
+}
+
+void DurationConstraintEdit::Collapse(bool collapse)
+{
+	_toggle->setVisible(collapse);
+	_duration->setVisible(!collapse);
+	_condition->setVisible(!collapse);
+}

src/general.cpp

@@ -1,9 +1,9 @@
-#include <QFileDialog>
-
 #include "headers/advanced-scene-switcher.hpp"
 #include "headers/utility.hpp"
 #include "headers/version.h"
 
+#include <QFileDialog>
+
 QMetaObject::Connection inactivePluse;
 
 void AdvSceneSwitcher::on_close_clicked()
@@ -156,8 +156,11 @@ void AdvSceneSwitcher::SetStopped()
 		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 ");
+	if (!switcher->disableHints) {
+		inactivePluse = PulseWidget(ui->pluginRunningText,
+					    QColor(Qt::red), QColor(0, 0, 0, 0),
+					    "QLabel ");
+	}
 	currentStatusActive = false;
 }
 
@@ -207,34 +210,6 @@ void AdvSceneSwitcher::on_uiHintsDisable_stateChanged(int state)
 	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)) {
-		return;
-	}
-
-	obs_data_save_json(obj, file.fileName().toUtf8().constData());
-}
-
 void AdvSceneSwitcher::on_exportSettings_clicked()
 {
 	QString directory = QFileDialog::getSaveFileName(

src/headers/advanced-scene-switcher.hpp

@@ -5,6 +5,7 @@
 #include "ui_advanced-scene-switcher.h"
 #endif
 #include "switcher-data-structs.hpp"
+#include "platform-funcs.hpp"
 
 #define blog(level, msg, ...) blog(level, "[adv-ss] " msg, ##__VA_ARGS__)
 #define vblog(level, msg, ...)                   \
@@ -13,6 +14,8 @@
 	}
 
 class QCloseEvent;
+class MacroActionEdit;
+class MacroConditionEdit;
 
 /*******************************************************************************
  * Advanced Scene Switcher window
@@ -46,6 +49,10 @@ public:
 	bool addNewMacro(std::string &name);
 	Macro *getSelectedMacro();
 	void SetEditMacro(Macro &m);
+	void ConnectControlSignals(MacroActionEdit *);
+	void ConnectControlSignals(MacroConditionEdit *);
+	void SwapActions(Macro *m, int pos1, int pos2);
+	void SwapConditions(Macro *m, int pos1, int pos2);
 
 	void loadUI();
 	void setupGeneralTab();
@@ -69,44 +76,10 @@ public:
 	void setTabOrder();
 	void restoreWindowGeo();
 
-	static void AskBackup(obs_data_t *obj);
-
-	static void addSelectionEntry(QComboBox *sel, const char *description,
-				      bool selectable = false,
-				      const char *tooltip = "");
-	static void populateSceneSelection(QComboBox *sel,
-					   bool addPrevious = false,
-					   bool addSceneGroup = false,
-					   bool addSelect = true,
-					   std::string selectText = "",
-					   bool selectable = false);
-
-	static void populateTransitionSelection(QComboBox *sel,
-						bool addCurrent = true,
-						bool addSelect = true,
-						bool selectable = false);
-	static void populateWindowSelection(QComboBox *sel,
-					    bool addSelect = true);
-	static void populateAudioSelection(QComboBox *sel,
-					   bool addSelect = true);
-	static void populateVideoSelection(QComboBox *sel,
-					   bool addScenes = true,
-					   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 MacroAdded(const QString &name);
+	void MacroRemoved(const QString &name);
+	void MacroRenamed(const QString &oldName, const QString newName);
 	void SceneGroupAdded(const QString &name);
 	void SceneGroupRemoved(const QString &name);
 	void SceneGroupRenamed(const QString &oldName, const QString newName);
@@ -137,12 +110,27 @@ public slots:
 	void on_macroDown_clicked();
 	void on_macroName_editingFinished();
 	void on_macros_currentRowChanged(int idx);
+	void on_macros_itemChanged(QListWidgetItem *);
 	void on_conditionAdd_clicked();
 	void on_conditionRemove_clicked();
 	void on_actionAdd_clicked();
 	void on_actionRemove_clicked();
-	void showMacroContextMenu(const QPoint &);
-	void copyMacro();
+	void ShowMacroContextMenu(const QPoint &);
+	void ShowMacroActionsContextMenu(const QPoint &);
+	void ShowMacroConditionsContextMenu(const QPoint &);
+	void CopyMacro();
+	void ExpandAllActions();
+	void ExpandAllConditions();
+	void CollapseAllActions();
+	void CollapseAllConditions();
+	void AddMacroAction(int idx);
+	void RemoveMacroAction(int idx);
+	void MoveMacroActionUp(int idx);
+	void MoveMacroActionDown(int idx);
+	void AddMacroCondition(int idx);
+	void RemoveMacroCondition(int idx);
+	void MoveMacroConditionUp(int idx);
+	void MoveMacroConditionDown(int idx);
 
 	void on_screenRegionSwitches_currentRowChanged(int idx);
 	void on_showFrame_clicked();
@@ -243,7 +231,9 @@ public slots:
 	void on_clientSettings_toggled(bool on);
 	void on_clientHostname_textChanged(const QString &text);
 	void on_clientPort_valueChanged(int value);
+	void on_sendSceneChange_stateChanged(int state);
 	void on_restrictSend_stateChanged(int state);
+	void on_sendPreview_stateChanged(int state);
 	void on_clientReconnect_clicked();
 	void updateClientStatus();
 
@@ -276,40 +266,17 @@ public slots:
 private:
 };
 
-/******************************************************************************
- * Windowtitle helper
- ******************************************************************************/
-void GetWindowList(std::vector<std::string> &windows);
-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
  ******************************************************************************/
 
-void setNextTransition(sceneSwitchInfo &ssi, obs_source_t *currentSource,
+void setNextTransition(const sceneSwitchInfo &ssi, obs_source_t *currentSource,
 		       transitionData &td);
-void overwriteTransitionOverride(sceneSwitchInfo ssi, transitionData &td);
-void restoreTransitionOverride(obs_source_t *scene, transitionData td);
-void switchScene(sceneSwitchInfo ssi);
+void overwriteTransitionOverride(const sceneSwitchInfo &ssi,
+				 transitionData &td);
+void restoreTransitionOverride(obs_source_t *scene, const transitionData &td);
+void switchScene(const sceneSwitchInfo &ssi);
+void switchPreviewScene(const OBSWeakSource &ws);
 
 /******************************************************************************
  * Main SwitcherData

src/headers/curl-helper.hpp

@@ -5,9 +5,9 @@
 #if defined(WIN32)
 constexpr auto curl_library_name = "libcurl.dll";
 #elif __APPLE__
-#define curl_library_name "libcurl.4.dylib"
+constexpr auto curl_library_name = "libcurl.4.dylib";
 #else
-#define curl_library_name "libcurl.so.4"
+constexpr auto curl_library_name = "libcurl.so.4";
 #endif
 
 typedef CURL *(*initFunction)(void);

src/headers/duration-control.hpp

@@ -2,6 +2,7 @@
 #include <QWidget>
 #include <QDoubleSpinBox>
 #include <QComboBox>
+#include <QPushButton>
 #include <chrono>
 
 #include "obs-data.h"
@@ -20,6 +21,7 @@ public:
 		  const char *unitName = "displayUnit");
 
 	bool DurationReached();
+	double TimeRemaining();
 	void Reset();
 	std::string ToString();
 
@@ -53,3 +55,57 @@ private:
 
 	double _unitMultiplier;
 };
+
+enum class DurationCondition {
+	NONE,
+	MORE,
+	EQUAL,
+	LESS,
+};
+
+class DurationConstraint {
+public:
+	void Save(obs_data_t *obj, const char *condName = "time_constraint",
+		  const char *secondsName = "seconds",
+		  const char *unitName = "displayUnit");
+	void Load(obs_data_t *obj, const char *condName = "time_constraint",
+		  const char *secondsName = "seconds",
+		  const char *unitName = "displayUnit");
+	void SetCondition(DurationCondition cond) { _type = cond; }
+	void SetDuration(const Duration &dur) { _dur = dur; }
+	void SetValue(double value) { _dur.seconds = value; }
+	void SetUnit(DurationUnit u) { _dur.displayUnit = u; }
+	DurationCondition GetCondition() { return _type; }
+	Duration GetDuration() { return _dur; }
+	bool DurationReached();
+	void Reset();
+
+private:
+	DurationCondition _type = DurationCondition::NONE;
+	Duration _dur;
+	bool _timeReached = false;
+};
+
+class DurationConstraintEdit : public QWidget {
+	Q_OBJECT
+public:
+	DurationConstraintEdit(QWidget *parent = nullptr);
+	void SetValue(DurationConstraint &value);
+	void SetUnit(DurationUnit u);
+	void SetDuration(const Duration &d);
+
+private slots:
+	void _ConditionChanged(int value);
+	void ToggleClicked();
+signals:
+	void DurationChanged(double value);
+	void UnitChanged(DurationUnit u);
+	void ConditionChanged(DurationCondition value);
+
+private:
+	void Collapse(bool collapse);
+
+	DurationSelection *_duration;
+	QComboBox *_condition;
+	QPushButton *_toggle;
+};

src/headers/hotkey.hpp

@@ -0,0 +1,125 @@
+#pragma once
+
+extern bool canSimulateKeyPresses;
+
+enum class HotkeyType {
+	Key_NoKey = 0,
+
+	Key_A,
+	Key_B,
+	Key_C,
+	Key_D,
+	Key_E,
+	Key_F,
+	Key_G,
+	Key_H,
+	Key_I,
+	Key_J,
+	Key_K,
+	Key_L,
+	Key_M,
+	Key_N,
+	Key_O,
+	Key_P,
+	Key_Q,
+	Key_R,
+	Key_S,
+	Key_T,
+	Key_U,
+	Key_V,
+	Key_W,
+	Key_X,
+	Key_Y,
+	Key_Z,
+
+	Key_0,
+	Key_1,
+	Key_2,
+	Key_3,
+	Key_4,
+	Key_5,
+	Key_6,
+	Key_7,
+	Key_8,
+	Key_9,
+
+	Key_F1,
+	Key_F2,
+	Key_F3,
+	Key_F4,
+	Key_F5,
+	Key_F6,
+	Key_F7,
+	Key_F8,
+	Key_F9,
+	Key_F10,
+	Key_F11,
+	Key_F12,
+	Key_F13,
+	Key_F14,
+	Key_F15,
+	Key_F16,
+	Key_F17,
+	Key_F18,
+	Key_F19,
+	Key_F20,
+	Key_F21,
+	Key_F22,
+	Key_F23,
+	Key_F24,
+
+	Key_Escape,
+	Key_Space,
+	Key_Return,
+	Key_Backspace,
+	Key_Tab,
+
+	Key_Shift_L,
+	Key_Shift_R,
+	Key_Control_L,
+	Key_Control_R,
+	Key_Alt_L,
+	Key_Alt_R,
+	Key_Win_L,
+	Key_Win_R,
+	Key_Apps,
+
+	Key_CapsLock,
+	Key_NumLock,
+	Key_ScrollLock,
+
+	Key_PrintScreen,
+	Key_Pause,
+
+	Key_Insert,
+	Key_Delete,
+	Key_PageUP,
+	Key_PageDown,
+	Key_Home,
+	Key_End,
+
+	Key_Left,
+	Key_Right,
+	Key_Up,
+	Key_Down,
+
+	Key_Numpad0,
+	Key_Numpad1,
+	Key_Numpad2,
+	Key_Numpad3,
+	Key_Numpad4,
+	Key_Numpad5,
+	Key_Numpad6,
+	Key_Numpad7,
+	Key_Numpad8,
+	Key_Numpad9,
+
+	Key_NumpadAdd,
+	Key_NumpadSubtract,
+	Key_NumpadMultiply,
+	Key_NumpadDivide,
+	Key_NumpadDecimal,
+	Key_NumpadEnter
+};
+
+void registerHotkeys();

src/headers/macro-action-audio.hpp

@@ -1,5 +1,6 @@
 #pragma once
 #include <QSpinBox>
+#include <QHBoxLayout>
 #include "macro-action-edit.hpp"
 
 enum class AudioAction {
@@ -15,7 +16,8 @@ public:
 	void LogAction();
 	bool Save(obs_data_t *obj);
 	bool Load(obs_data_t *obj);
-	int GetId() { return id; };
+	std::string GetShortDesc();
+	std::string GetId() { return id; };
 	static std::shared_ptr<MacroAction> Create()
 	{
 		return std::make_shared<MacroActionAudio>();
@@ -27,7 +29,7 @@ public:
 
 private:
 	static bool _registered;
-	static const int id;
+	static const std::string id;
 };
 
 class MacroActionAudioEdit : public QWidget {
@@ -37,6 +39,7 @@ public:
 	MacroActionAudioEdit(
 		QWidget *parent,
 		std::shared_ptr<MacroActionAudio> entryData = nullptr);
+	void SetWidgetVisibility();
 	void UpdateEntryData();
 	static QWidget *Create(QWidget *parent,
 			       std::shared_ptr<MacroAction> action)
@@ -50,6 +53,8 @@ private slots:
 	void SourceChanged(const QString &text);
 	void ActionChanged(int value);
 	void VolumeChanged(int value);
+signals:
+	void HeaderInfoChanged(const QString &);
 
 protected:
 	QComboBox *_audioSources;

src/headers/macro-action-edit.hpp

@@ -1,12 +1,5 @@
 #pragma once
-
-#include <QWidget>
-#include <QComboBox>
-#include <QVBoxLayout>
-#include <QGroupBox>
-#include <deque>
 #include "macro.hpp"
-#include "section.hpp"
 
 struct MacroActionInfo {
 	using TCreateMethod = std::shared_ptr<MacroAction> (*)();
@@ -20,35 +13,35 @@ struct MacroActionInfo {
 class MacroActionFactory {
 public:
 	MacroActionFactory() = delete;
-	static bool Register(int id, MacroActionInfo);
-	static std::shared_ptr<MacroAction> Create(const int id);
-	static QWidget *CreateWidget(const int id, QWidget *parent,
+	static bool Register(const std::string &id, MacroActionInfo);
+	static std::shared_ptr<MacroAction> Create(const std::string &id);
+	static QWidget *CreateWidget(const std::string &id, QWidget *parent,
 				     std::shared_ptr<MacroAction> action);
 	static auto GetActionTypes() { return _methods; }
+	static std::string GetActionName(const std::string &id);
+	static std::string GetIdByName(const QString &name);
 
 private:
-	static std::map<int, MacroActionInfo> _methods;
+	static std::map<std::string, MacroActionInfo> _methods;
 };
 
-class MacroActionEdit : public QWidget {
+class MacroActionEdit : public MacroSegmentEdit {
 	Q_OBJECT
 
 public:
 	MacroActionEdit(QWidget *parent = nullptr,
-			std::shared_ptr<MacroAction> * = nullptr, int type = 0,
-			bool startCollapsed = false);
-	void UpdateEntryData(int type);
-	void Collapse(bool collapsed);
+			std::shared_ptr<MacroAction> * = nullptr,
+			const std::string &id = "scene_switch");
+	void UpdateEntryData(const std::string &id);
 
 private slots:
-	void ActionSelectionChanged(int idx);
-
-protected:
-	QComboBox *_actionSelection;
-	Section *_section;
-
-	std::shared_ptr<MacroAction> *_entryData;
+	void ActionSelectionChanged(const QString &text);
 
 private:
+	MacroSegment *Data();
+
+	QComboBox *_actionSelection;
+
+	std::shared_ptr<MacroAction> *_entryData;
 	bool _loading = true;
 };

src/headers/macro-action-file.hpp

@@ -0,0 +1,66 @@
+#pragma once
+#include <QSpinBox>
+#include <QPlainTextEdit>
+#include "macro-action-edit.hpp"
+
+enum class FileAction {
+	WRITE,
+	APPEND,
+};
+
+class MacroActionFile : public MacroAction {
+public:
+	bool PerformAction();
+	void LogAction();
+	bool Save(obs_data_t *obj);
+	bool Load(obs_data_t *obj);
+	std::string GetShortDesc();
+	std::string GetId() { return id; };
+	static std::shared_ptr<MacroAction> Create()
+	{
+		return std::make_shared<MacroActionFile>();
+	}
+
+	std::string _file = obs_module_text("AdvSceneSwitcher.enterPath");
+	std::string _text = obs_module_text("AdvSceneSwitcher.enterText");
+	FileAction _action = FileAction::WRITE;
+
+private:
+	static bool _registered;
+	static const std::string id;
+};
+
+class MacroActionFileEdit : public QWidget {
+	Q_OBJECT
+
+public:
+	MacroActionFileEdit(
+		QWidget *parent,
+		std::shared_ptr<MacroActionFile> entryData = nullptr);
+	void UpdateEntryData();
+	static QWidget *Create(QWidget *parent,
+			       std::shared_ptr<MacroAction> action)
+	{
+		return new MacroActionFileEdit(
+			parent,
+			std::dynamic_pointer_cast<MacroActionFile>(action));
+	}
+
+private slots:
+	void FilePathChanged();
+	void BrowseButtonClicked();
+	void TextChanged();
+	void ActionChanged(int value);
+signals:
+	void HeaderInfoChanged(const QString &);
+
+protected:
+	QLineEdit *_filePath;
+	QPushButton *_browseButton;
+	QPlainTextEdit *_text;
+	QComboBox *_actions;
+	std::shared_ptr<MacroActionFile> _entryData;
+
+private:
+	bool _loading = true;
+};

src/headers/macro-action-filter.hpp

@@ -0,0 +1,71 @@
+#pragma once
+#include <QSpinBox>
+#include <QPlainTextEdit>
+#include "macro-action-edit.hpp"
+
+enum class FilterAction {
+	ENABLE,
+	DISABLE,
+	SETTINGS,
+};
+
+class MacroActionFilter : public MacroAction {
+public:
+	bool PerformAction();
+	void LogAction();
+	bool Save(obs_data_t *obj);
+	bool Load(obs_data_t *obj);
+	std::string GetShortDesc();
+	std::string GetId() { return id; };
+	static std::shared_ptr<MacroAction> Create()
+	{
+		return std::make_shared<MacroActionFilter>();
+	}
+
+	OBSWeakSource _source;
+	OBSWeakSource _filter;
+	FilterAction _action = FilterAction::ENABLE;
+	std::string _settings = "";
+
+private:
+	static bool _registered;
+	static const std::string id;
+};
+
+class MacroActionFilterEdit : public QWidget {
+	Q_OBJECT
+
+public:
+	MacroActionFilterEdit(
+		QWidget *parent,
+		std::shared_ptr<MacroActionFilter> entryData = nullptr);
+	void UpdateEntryData();
+	static QWidget *Create(QWidget *parent,
+			       std::shared_ptr<MacroAction> action)
+	{
+		return new MacroActionFilterEdit(
+			parent,
+			std::dynamic_pointer_cast<MacroActionFilter>(action));
+	}
+
+private slots:
+	void SourceChanged(const QString &text);
+	void FilterChanged(const QString &text);
+	void ActionChanged(int value);
+	void GetSettingsClicked();
+	void SettingsChanged();
+signals:
+	void HeaderInfoChanged(const QString &);
+
+protected:
+	QComboBox *_sources;
+	QComboBox *_filters;
+	QComboBox *_actions;
+	QPushButton *_getSettings;
+	QPlainTextEdit *_settings;
+	std::shared_ptr<MacroActionFilter> _entryData;
+
+private:
+	void SetWidgetVisibility(bool);
+	bool _loading = true;
+};

src/headers/macro-action-hotkey.hpp

@@ -0,0 +1,79 @@
+#pragma once
+#include "macro-action-edit.hpp"
+#include "hotkey.hpp"
+
+#include <QCheckBox>
+#include <QHBoxLayout>
+
+class MacroActionHotkey : public MacroAction {
+public:
+	bool PerformAction();
+	void LogAction();
+	bool Save(obs_data_t *obj);
+	bool Load(obs_data_t *obj);
+	std::string GetId() { return id; };
+	static std::shared_ptr<MacroAction> Create()
+	{
+		return std::make_shared<MacroActionHotkey>();
+	}
+
+	OBSWeakSource _HotkeySource;
+	HotkeyType _key = HotkeyType::Key_NoKey;
+	bool _leftShift = false;
+	bool _rightShift = false;
+	bool _leftCtrl = false;
+	bool _rightCtrl = false;
+	bool _leftAlt = false;
+	bool _rightAlt = false;
+	bool _leftMeta = false;
+	bool _rightMeta = false;
+
+private:
+	static bool _registered;
+	static const std::string id;
+};
+
+class MacroActionHotkeyEdit : public QWidget {
+	Q_OBJECT
+
+public:
+	MacroActionHotkeyEdit(
+		QWidget *parent,
+		std::shared_ptr<MacroActionHotkey> entryData = nullptr);
+	void UpdateEntryData();
+	static QWidget *Create(QWidget *parent,
+			       std::shared_ptr<MacroAction> action)
+	{
+		return new MacroActionHotkeyEdit(
+			parent,
+			std::dynamic_pointer_cast<MacroActionHotkey>(action));
+	}
+
+private slots:
+	void KeyChanged(int key);
+	void LShiftChanged(int state);
+	void RShiftChanged(int state);
+	void LCtrlChanged(int state);
+	void RCtrlChanged(int state);
+	void LAltChanged(int state);
+	void RAltChanged(int state);
+	void LMetaChanged(int state);
+	void RMetaChanged(int state);
+
+protected:
+	QComboBox *_keys;
+	QCheckBox *_leftShift;
+	QCheckBox *_rightShift;
+	QCheckBox *_leftCtrl;
+	QCheckBox *_rightCtrl;
+	QCheckBox *_leftAlt;
+	QCheckBox *_rightAlt;
+	QCheckBox *_leftMeta;
+	QCheckBox *_rightMeta;
+
+	std::shared_ptr<MacroActionHotkey> _entryData;
+
+private:
+	QHBoxLayout *_mainLayout;
+	bool _loading = true;
+};

src/headers/macro-action-macro.hpp

@@ -0,0 +1,64 @@
+#pragma once
+#include "macro-action-edit.hpp"
+#include "macro-selection.hpp"
+
+#include <QHBoxLayout>
+
+enum class PerformMacroAction {
+	PAUSE,
+	UNPAUSE,
+	RESET_COUNTER,
+};
+
+class MacroActionMacro : public MacroRefAction {
+public:
+	bool PerformAction();
+	void LogAction();
+	bool Save(obs_data_t *obj);
+	bool Load(obs_data_t *obj);
+	std::string GetShortDesc();
+	std::string GetId() { return id; };
+	static std::shared_ptr<MacroAction> Create()
+	{
+		return std::make_shared<MacroActionMacro>();
+	}
+
+	PerformMacroAction _action = PerformMacroAction::PAUSE;
+
+private:
+	static bool _registered;
+	static const std::string id;
+};
+
+class MacroActionMacroEdit : public QWidget {
+	Q_OBJECT
+
+public:
+	MacroActionMacroEdit(
+		QWidget *parent,
+		std::shared_ptr<MacroActionMacro> entryData = nullptr);
+	void UpdateEntryData();
+	static QWidget *Create(QWidget *parent,
+			       std::shared_ptr<MacroAction> action)
+	{
+		return new MacroActionMacroEdit(
+			parent,
+			std::dynamic_pointer_cast<MacroActionMacro>(action));
+	}
+
+private slots:
+	void MacroChanged(const QString &text);
+	void MacroRemove(const QString &name);
+	void ActionChanged(int value);
+signals:
+	void HeaderInfoChanged(const QString &);
+
+protected:
+	MacroSelection *_macros;
+	QComboBox *_actions;
+	std::shared_ptr<MacroActionMacro> _entryData;
+
+private:
+	QHBoxLayout *_mainLayout;
+	bool _loading = true;
+};

src/headers/macro-action-media.hpp

@@ -0,0 +1,67 @@
+#pragma once
+#include "macro-action-edit.hpp"
+
+#include <QSpinBox>
+#include <QHBoxLayout>
+
+enum class MediaAction {
+	PLAY,
+	PAUSE,
+	STOP,
+	RESTART,
+	NEXT,
+	PREVIOUS,
+};
+
+class MacroActionMedia : public MacroAction {
+public:
+	bool PerformAction();
+	void LogAction();
+	bool Save(obs_data_t *obj);
+	bool Load(obs_data_t *obj);
+	std::string GetShortDesc();
+	std::string GetId() { return id; };
+	static std::shared_ptr<MacroAction> Create()
+	{
+		return std::make_shared<MacroActionMedia>();
+	}
+
+	OBSWeakSource _mediaSource;
+	MediaAction _action = MediaAction::PLAY;
+
+private:
+	static bool _registered;
+	static const std::string id;
+};
+
+class MacroActionMediaEdit : public QWidget {
+	Q_OBJECT
+
+public:
+	MacroActionMediaEdit(
+		QWidget *parent,
+		std::shared_ptr<MacroActionMedia> entryData = nullptr);
+	void UpdateEntryData();
+	static QWidget *Create(QWidget *parent,
+			       std::shared_ptr<MacroAction> action)
+	{
+		return new MacroActionMediaEdit(
+			parent,
+			std::dynamic_pointer_cast<MacroActionMedia>(action));
+	}
+
+private slots:
+	void SourceChanged(const QString &text);
+	void ActionChanged(int value);
+signals:
+	void HeaderInfoChanged(const QString &);
+
+protected:
+	QComboBox *_mediaSources;
+	QComboBox *_actions;
+	std::shared_ptr<MacroActionMedia> _entryData;
+
+private:
+	QHBoxLayout *_mainLayout;
+	bool _loading = true;
+};

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

@@ -0,0 +1,65 @@
+#pragma once
+#include "macro-action-edit.hpp"
+
+#include <QDoubleSpinBox>
+#include <QHBoxLayout>
+
+enum class PluginStateAction {
+	STOP,
+	NO_MATCH_BEHAVIOUR,
+};
+
+class MacroActionPluginState : public MacroAction {
+public:
+	bool PerformAction();
+	void LogAction();
+	bool Save(obs_data_t *obj);
+	bool Load(obs_data_t *obj);
+	std::string GetId() { return id; };
+	static std::shared_ptr<MacroAction> Create()
+	{
+		return std::make_shared<MacroActionPluginState>();
+	}
+
+	PluginStateAction _action = PluginStateAction::STOP;
+	int _value = 0;
+	OBSWeakSource _scene;
+
+private:
+	static bool _registered;
+	static const std::string id;
+};
+
+class MacroActionPluginStateEdit : public QWidget {
+	Q_OBJECT
+
+public:
+	MacroActionPluginStateEdit(
+		QWidget *parent,
+		std::shared_ptr<MacroActionPluginState> entryData = nullptr);
+	void UpdateEntryData();
+	static QWidget *Create(QWidget *parent,
+			       std::shared_ptr<MacroAction> action)
+	{
+		return new MacroActionPluginStateEdit(
+			parent,
+			std::dynamic_pointer_cast<MacroActionPluginState>(
+				action));
+	}
+
+private slots:
+	void ActionChanged(int value);
+	void ValueChanged(int value);
+	void SceneChanged(const QString &text);
+
+protected:
+	QComboBox *_actions;
+	QComboBox *_values;
+	QComboBox *_scenes;
+	std::shared_ptr<MacroActionPluginState> _entryData;
+
+private:
+	void SetWidgetVisibility(PluginStateAction, int);
+	QHBoxLayout *_mainLayout;
+	bool _loading = true;
+};

src/headers/macro-action-recording.hpp

@@ -1,8 +1,9 @@
 #pragma once
-#include <QDoubleSpinBox>
-#include <QLabel>
 #include "macro-action-edit.hpp"
 
+#include <QComboBox>
+#include <QHBoxLayout>
+
 enum class RecordAction {
 	STOP,
 	START,
@@ -16,7 +17,7 @@ public:
 	void LogAction();
 	bool Save(obs_data_t *obj);
 	bool Load(obs_data_t *obj);
-	int GetId() { return id; };
+	std::string GetId() { return id; };
 	static std::shared_ptr<MacroAction> Create()
 	{
 		return std::make_shared<MacroActionRecord>();
@@ -26,7 +27,7 @@ public:
 
 private:
 	static bool _registered;
-	static const int id;
+	static const std::string id;
 };
 
 class MacroActionRecordEdit : public QWidget {

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

@@ -1,8 +1,9 @@
 #pragma once
-#include <QDoubleSpinBox>
 #include "macro-action-edit.hpp"
 #include "duration-control.hpp"
 
+#include <QHBoxLayout>
+
 enum class ReplayBufferAction {
 	STOP,
 	START,
@@ -15,7 +16,7 @@ public:
 	void LogAction();
 	bool Save(obs_data_t *obj);
 	bool Load(obs_data_t *obj);
-	int GetId() { return id; };
+	std::string GetId() { return id; };
 	static std::shared_ptr<MacroAction> Create()
 	{
 		return std::make_shared<MacroActionReplayBuffer>();
@@ -33,7 +34,7 @@ private:
 	Duration _duration;
 
 	static bool _registered;
-	static const int id;
+	static const std::string id;
 };
 
 class MacroActionReplayBufferEdit : public QWidget {

src/headers/macro-action-run.hpp

@@ -3,6 +3,8 @@
 
 #include <QLineEdit>
 #include <QPushButton>
+#include <QListWidget>
+#include <QStringList>
 
 class MacroActionRun : public MacroAction {
 public:
@@ -10,17 +12,19 @@ public:
 	void LogAction();
 	bool Save(obs_data_t *obj);
 	bool Load(obs_data_t *obj);
-	int GetId() { return id; };
+	std::string GetShortDesc();
+	std::string GetId() { return id; };
 	static std::shared_ptr<MacroAction> Create()
 	{
 		return std::make_shared<MacroActionRun>();
 	}
 
 	std::string _path = obs_module_text("AdvSceneSwitcher.enterPath");
+	QStringList _args;
 
 private:
 	static bool _registered;
-	static const int id;
+	static const std::string id;
 };
 
 class MacroActionRunEdit : public QWidget {
@@ -41,6 +45,12 @@ public:
 private slots:
 	void FilePathChanged();
 	void BrowseButtonClicked();
+	void AddArg();
+	void RemoveArg();
+	void ArgUp();
+	void ArgDown();
+signals:
+	void HeaderInfoChanged(const QString &);
 
 protected:
 	std::shared_ptr<MacroActionRun> _entryData;
@@ -48,5 +58,10 @@ protected:
 private:
 	QLineEdit *_filePath;
 	QPushButton *_browseButton;
+	QListWidget *_argList;
+	QPushButton *_addArg;
+	QPushButton *_removeArg;
+	QPushButton *_argUp;
+	QPushButton *_argDown;
 	bool _loading = true;
 };

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

@@ -0,0 +1,72 @@
+#pragma once
+#include <QSpinBox>
+#include "macro-action-edit.hpp"
+#include "scene-selection.hpp"
+
+enum class SceneOrderAction {
+	MOVE_UP,
+	MOVE_DOWN,
+	MOVE_TOP,
+	MOVE_BOTTOM,
+	POSITION,
+};
+
+class MacroActionSceneOrder : public MacroAction {
+public:
+	bool PerformAction();
+	void LogAction();
+	bool Save(obs_data_t *obj);
+	bool Load(obs_data_t *obj);
+	std::string GetShortDesc();
+	std::string GetId() { return id; };
+	static std::shared_ptr<MacroAction> Create()
+	{
+		return std::make_shared<MacroActionSceneOrder>();
+	}
+
+	SceneSelection _scene;
+	OBSWeakSource _source;
+	SceneOrderAction _action = SceneOrderAction::MOVE_UP;
+	int _position = 0;
+
+private:
+	static bool _registered;
+	static const std::string id;
+};
+
+class MacroActionSceneOrderEdit : public QWidget {
+	Q_OBJECT
+
+public:
+	MacroActionSceneOrderEdit(
+		QWidget *parent,
+		std::shared_ptr<MacroActionSceneOrder> entryData = nullptr);
+	void UpdateEntryData();
+	static QWidget *Create(QWidget *parent,
+			       std::shared_ptr<MacroAction> action)
+	{
+		return new MacroActionSceneOrderEdit(
+			parent,
+			std::dynamic_pointer_cast<MacroActionSceneOrder>(
+				action));
+	}
+
+private slots:
+	void SceneChanged(const SceneSelection &);
+	void SourceChanged(const QString &text);
+	void ActionChanged(int value);
+	void PositionChanged(int value);
+signals:
+	void HeaderInfoChanged(const QString &);
+
+protected:
+	SceneSelectionWidget *_scenes;
+	QComboBox *_sources;
+	QComboBox *_actions;
+	QSpinBox *_position;
+	std::shared_ptr<MacroActionSceneOrder> _entryData;
+
+private:
+	QHBoxLayout *_mainLayout;
+	bool _loading = true;
+};

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

@@ -3,13 +3,16 @@
 #include "switch-generic.hpp"
 #include "duration-control.hpp"
 
+// TODO: Switch to using SceneSelection class and widget instead
+
 class MacroActionSwitchScene : public MacroAction, public SceneSwitcherEntry {
 public:
 	bool PerformAction();
 	void LogAction();
 	bool Save(obs_data_t *obj);
 	bool Load(obs_data_t *obj);
-	int GetId() { return id; };
+	std::string GetShortDesc();
+	std::string GetId() { return id; };
 
 	static std::shared_ptr<MacroAction> Create()
 	{
@@ -21,7 +24,7 @@ private:
 	const char *getType() { return "MacroActionSwitchScene"; }
 
 	static bool _registered;
-	static const int id;
+	static const std::string id;
 };
 
 class MacroActionSwitchSceneEdit : public SwitchWidget {
@@ -42,6 +45,9 @@ public:
 
 private slots:
 	void DurationChanged(double seconds);
+	void ChangeHeaderInfo(const QString &);
+signals:
+	void HeaderInfoChanged(const QString &);
 
 protected:
 	DurationSelection *_duration;

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

@@ -0,0 +1,66 @@
+#pragma once
+#include <QSpinBox>
+#include <QPlainTextEdit>
+#include "macro-action-edit.hpp"
+#include "scene-selection.hpp"
+
+class MacroActionSceneTransform : public MacroAction {
+public:
+	bool PerformAction();
+	void LogAction();
+	bool Save(obs_data_t *obj);
+	bool Load(obs_data_t *obj);
+	std::string GetShortDesc();
+	std::string GetId() { return id; };
+	static std::shared_ptr<MacroAction> Create()
+	{
+		return std::make_shared<MacroActionSceneTransform>();
+	}
+	std::string GetSettings();
+	void SetSettings(std::string &);
+
+	SceneSelection _scene;
+	OBSWeakSource _source;
+	struct obs_transform_info _info;
+	struct obs_sceneitem_crop _crop;
+
+private:
+	static bool _registered;
+	static const std::string id;
+};
+
+class MacroActionSceneTransformEdit : public QWidget {
+	Q_OBJECT
+
+public:
+	MacroActionSceneTransformEdit(
+		QWidget *parent,
+		std::shared_ptr<MacroActionSceneTransform> entryData = nullptr);
+	void UpdateEntryData();
+	static QWidget *Create(QWidget *parent,
+			       std::shared_ptr<MacroAction> action)
+	{
+		return new MacroActionSceneTransformEdit(
+			parent,
+			std::dynamic_pointer_cast<MacroActionSceneTransform>(
+				action));
+	}
+
+private slots:
+	void SceneChanged(const SceneSelection &);
+	void SourceChanged(const QString &text);
+	void GetSettingsClicked();
+	void SettingsChanged();
+signals:
+	void HeaderInfoChanged(const QString &);
+
+protected:
+	SceneSelectionWidget *_scenes;
+	QComboBox *_sources;
+	QPushButton *_getSettings;
+	QPlainTextEdit *_settings;
+	std::shared_ptr<MacroActionSceneTransform> _entryData;
+
+private:
+	bool _loading = true;
+};

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

@@ -0,0 +1,66 @@
+#pragma once
+#include <QSpinBox>
+#include "macro-action-edit.hpp"
+#include "scene-selection.hpp"
+
+enum class SceneVisibilityAction {
+	SHOW,
+	HIDE,
+};
+
+class MacroActionSceneVisibility : public MacroAction {
+public:
+	bool PerformAction();
+	void LogAction();
+	bool Save(obs_data_t *obj);
+	bool Load(obs_data_t *obj);
+	std::string GetShortDesc();
+	std::string GetId() { return id; };
+	static std::shared_ptr<MacroAction> Create()
+	{
+		return std::make_shared<MacroActionSceneVisibility>();
+	}
+
+	SceneSelection _scene;
+	OBSWeakSource _source;
+	SceneVisibilityAction _action = SceneVisibilityAction::SHOW;
+
+private:
+	static bool _registered;
+	static const std::string id;
+};
+
+class MacroActionSceneVisibilityEdit : public QWidget {
+	Q_OBJECT
+
+public:
+	MacroActionSceneVisibilityEdit(
+		QWidget *parent,
+		std::shared_ptr<MacroActionSceneVisibility> entryData = nullptr);
+	void UpdateEntryData();
+	static QWidget *Create(QWidget *parent,
+			       std::shared_ptr<MacroAction> action)
+	{
+		return new MacroActionSceneVisibilityEdit(
+			parent,
+			std::dynamic_pointer_cast<MacroActionSceneVisibility>(
+				action));
+	}
+
+private slots:
+	void SceneChanged(const SceneSelection &);
+	void SourceChanged(const QString &text);
+	void ActionChanged(int value);
+signals:
+	void HeaderInfoChanged(const QString &);
+
+protected:
+	SceneSelectionWidget *_scenes;
+	QComboBox *_sources;
+	QComboBox *_actions;
+	std::shared_ptr<MacroActionSceneVisibility> _entryData;
+
+private:
+	QHBoxLayout *_mainLayout;
+	bool _loading = true;
+};

src/headers/macro-action-source.hpp

@@ -0,0 +1,72 @@
+#pragma once
+#include "macro-action-edit.hpp"
+
+#include <QSpinBox>
+#include <QLabel>
+#include <QPushButton>
+#include <QPlainTextEdit>
+
+enum class SourceAction {
+	ENABLE,
+	DISABLE,
+	SETTINGS,
+};
+
+class MacroActionSource : public MacroAction {
+public:
+	bool PerformAction();
+	void LogAction();
+	bool Save(obs_data_t *obj);
+	bool Load(obs_data_t *obj);
+	std::string GetShortDesc();
+	std::string GetId() { return id; };
+	static std::shared_ptr<MacroAction> Create()
+	{
+		return std::make_shared<MacroActionSource>();
+	}
+
+	OBSWeakSource _source;
+	std::string _settings = "";
+	SourceAction _action = SourceAction::ENABLE;
+
+private:
+	static bool _registered;
+	static const std::string id;
+};
+
+class MacroActionSourceEdit : public QWidget {
+	Q_OBJECT
+
+public:
+	MacroActionSourceEdit(
+		QWidget *parent,
+		std::shared_ptr<MacroActionSource> entryData = nullptr);
+	void UpdateEntryData();
+	static QWidget *Create(QWidget *parent,
+			       std::shared_ptr<MacroAction> action)
+	{
+		return new MacroActionSourceEdit(
+			parent,
+			std::dynamic_pointer_cast<MacroActionSource>(action));
+	}
+
+private slots:
+	void SourceChanged(const QString &text);
+	void ActionChanged(int value);
+	void GetSettingsClicked();
+	void SettingsChanged();
+signals:
+	void HeaderInfoChanged(const QString &);
+
+protected:
+	QComboBox *_sources;
+	QComboBox *_actions;
+	QPushButton *_getSettings;
+	QPlainTextEdit *_settings;
+	QLabel *_warning;
+	std::shared_ptr<MacroActionSource> _entryData;
+
+private:
+	void SetWidgetVisibility(bool);
+	bool _loading = true;
+};

src/headers/macro-action-streaming.hpp

@@ -1,8 +1,11 @@
 #pragma once
-#include <QDoubleSpinBox>
 #include "macro-action-edit.hpp"
 #include "duration-control.hpp"
 
+#include <QDoubleSpinBox>
+#include <QComboBox>
+#include <QHBoxLayout>
+
 enum class StreamAction {
 	STOP,
 	START,
@@ -14,7 +17,7 @@ public:
 	void LogAction();
 	bool Save(obs_data_t *obj);
 	bool Load(obs_data_t *obj);
-	int GetId() { return id; };
+	std::string GetId() { return id; };
 	static std::shared_ptr<MacroAction> Create()
 	{
 		return std::make_shared<MacroActionStream>();
@@ -28,7 +31,7 @@ private:
 	Duration _retryCooldown;
 
 	static bool _registered;
-	static const int id;
+	static const std::string id;
 };
 
 class MacroActionStreamEdit : public QWidget {

src/headers/macro-action-virtual-cam.hpp

@@ -0,0 +1,57 @@
+#pragma once
+#include "macro-action-edit.hpp"
+
+#include <QComboBox>
+#include <QHBoxLayout>
+
+enum class VCamAction {
+	STOP,
+	START,
+};
+
+class MacroActionVCam : public MacroAction {
+public:
+	bool PerformAction();
+	void LogAction();
+	bool Save(obs_data_t *obj);
+	bool Load(obs_data_t *obj);
+	std::string GetId() { return id; };
+	static std::shared_ptr<MacroAction> Create()
+	{
+		return std::make_shared<MacroActionVCam>();
+	}
+
+	VCamAction _action = VCamAction::STOP;
+
+private:
+	static bool _registered;
+	static const std::string id;
+};
+
+class MacroActionVCamEdit : public QWidget {
+	Q_OBJECT
+
+public:
+	MacroActionVCamEdit(
+		QWidget *parent,
+		std::shared_ptr<MacroActionVCam> entryData = nullptr);
+	void UpdateEntryData();
+	static QWidget *Create(QWidget *parent,
+			       std::shared_ptr<MacroAction> action)
+	{
+		return new MacroActionVCamEdit(
+			parent,
+			std::dynamic_pointer_cast<MacroActionVCam>(action));
+	}
+
+private slots:
+	void ActionChanged(int value);
+
+protected:
+	QComboBox *_actions;
+	std::shared_ptr<MacroActionVCam> _entryData;
+
+private:
+	QHBoxLayout *_mainLayout;
+	bool _loading = true;
+};

src/headers/macro-action-wait.hpp

@@ -1,8 +1,10 @@
 #pragma once
-#include <QDoubleSpinBox>
 #include "macro-action-edit.hpp"
 #include "duration-control.hpp"
 
+#include <QDoubleSpinBox>
+#include <QHBoxLayout>
+
 enum class WaitType {
 	FIXED,
 	RANDOM,
@@ -13,7 +15,7 @@ public:
 	bool PerformAction();
 	bool Save(obs_data_t *obj);
 	bool Load(obs_data_t *obj);
-	int GetId() { return id; };
+	std::string GetId() { return id; };
 	static std::shared_ptr<MacroAction> Create()
 	{
 		return std::make_shared<MacroActionWait>();
@@ -24,7 +26,7 @@ public:
 
 private:
 	static bool _registered;
-	static const int id;
+	static const std::string id;
 };
 
 class MacroActionWaitEdit : public QWidget {

src/headers/macro-condition-audio.hpp

@@ -6,8 +6,6 @@
 #include <QComboBox>
 #include <chrono>
 
-#include "duration-control.hpp"
-
 enum class AudioCondition {
 	ABOVE,
 	BELOW,
@@ -19,7 +17,8 @@ public:
 	bool CheckCondition();
 	bool Save(obs_data_t *obj);
 	bool Load(obs_data_t *obj);
-	int GetId() { return id; };
+	std::string GetShortDesc();
+	std::string GetId() { return id; };
 	static std::shared_ptr<MacroCondition> Create()
 	{
 		return std::make_shared<MacroConditionAudio>();
@@ -33,13 +32,12 @@ public:
 	OBSWeakSource _audioSource;
 	int _volume = 0;
 	AudioCondition _condition = AudioCondition::ABOVE;
-	Duration _duration;
 	obs_volmeter_t *_volmeter = nullptr;
 
 private:
 	float _peak = -std::numeric_limits<float>::infinity();
 	static bool _registered;
-	static const int id;
+	static const std::string id;
 };
 
 class MacroConditionAudioEdit : public QWidget {
@@ -63,13 +61,13 @@ private slots:
 	void SourceChanged(const QString &text);
 	void VolumeThresholdChanged(int vol);
 	void ConditionChanged(int cond);
-	void DurationChanged(double seconds);
+signals:
+	void HeaderInfoChanged(const QString &);
 
 protected:
 	QComboBox *_audioSources;
 	QComboBox *_condition;
 	QSpinBox *_volume;
-	DurationSelection *_duration;
 	VolControl *_volMeter = nullptr;
 	std::shared_ptr<MacroConditionAudio> _entryData;
 

src/headers/macro-condition-cursor.hpp

@@ -0,0 +1,76 @@
+#pragma once
+#include "macro.hpp"
+
+#include <QSpinBox>
+#include <QComboBox>
+#include <QPushButton>
+#include <QTimer>
+#include <QFrame>
+
+enum class CursorCondition {
+	REGION,
+	MOVING,
+};
+
+class MacroConditionCursor : public MacroCondition {
+public:
+	bool CheckCondition();
+	bool Save(obs_data_t *obj);
+	bool Load(obs_data_t *obj);
+	std::string GetId() { return id; };
+	static std::shared_ptr<MacroCondition> Create()
+	{
+		return std::make_shared<MacroConditionCursor>();
+	}
+
+	CursorCondition _condition = CursorCondition::REGION;
+	int _minX = 0, _minY = 0, _maxX = 0, _maxY = 0;
+
+private:
+	static bool _registered;
+	static const std::string id;
+};
+
+class MacroConditionCursorEdit : public QWidget {
+	Q_OBJECT
+
+public:
+	MacroConditionCursorEdit(
+		QWidget *parent,
+		std::shared_ptr<MacroConditionCursor> cond = nullptr);
+	void UpdateEntryData();
+	static QWidget *Create(QWidget *parent,
+			       std::shared_ptr<MacroCondition> cond)
+	{
+		return new MacroConditionCursorEdit(
+			parent,
+			std::dynamic_pointer_cast<MacroConditionCursor>(cond));
+	}
+
+private slots:
+	void ConditionChanged(int cond);
+	void MinXChanged(int pos);
+	void MinYChanged(int pos);
+	void MaxXChanged(int pos);
+	void MaxYChanged(int pos);
+	void UpdateCursorPos();
+	void ToggleFrame();
+
+protected:
+	QSpinBox *_minX;
+	QSpinBox *_minY;
+	QSpinBox *_maxX;
+	QSpinBox *_maxY;
+	QComboBox *_conditions;
+	QPushButton *_frameToggle;
+	QLabel *_xPos;
+	QLabel *_yPos;
+	std::shared_ptr<MacroConditionCursor> _entryData;
+
+private:
+	void SetRegionSelectionVisible(bool);
+	void SetupFrame();
+	QTimer _timer;
+	QFrame _frame;
+	bool _loading = true;
+};

src/headers/macro-condition-date.hpp

@@ -0,0 +1,82 @@
+#pragma once
+#include "macro.hpp"
+#include "duration-control.hpp"
+
+#include <QCheckBox>
+#include <QDateTimeEdit>
+#include <QComboBox>
+
+enum class DateCondition {
+	AT,
+	AFTER,
+	BEFORE,
+	BETWEEN,
+};
+
+class MacroConditionDate : public MacroCondition {
+public:
+	bool CheckCondition();
+	bool Save(obs_data_t *obj);
+	bool Load(obs_data_t *obj);
+	std::string GetShortDesc();
+	std::string GetId() { return id; };
+	static std::shared_ptr<MacroCondition> Create()
+	{
+		return std::make_shared<MacroConditionDate>();
+	}
+
+	QDateTime _dateTime;
+	QDateTime _dateTime2;
+	bool _ignoreDate = false;
+	bool _ignoreTime = false;
+	bool _repeat = false;
+	Duration _duration;
+	DateCondition _condition = DateCondition::AT;
+
+private:
+	static bool _registered;
+	static const std::string id;
+};
+
+class MacroConditionDateEdit : public QWidget {
+	Q_OBJECT
+
+public:
+	MacroConditionDateEdit(
+		QWidget *parent,
+		std::shared_ptr<MacroConditionDate> cond = nullptr);
+	void UpdateEntryData();
+	static QWidget *Create(QWidget *parent,
+			       std::shared_ptr<MacroCondition> cond)
+	{
+		return new MacroConditionDateEdit(
+			parent,
+			std::dynamic_pointer_cast<MacroConditionDate>(cond));
+	}
+
+private slots:
+	void ConditionChanged(int cond);
+	void DateTimeChanged(const QDateTime &datetime);
+	void DateTime2Changed(const QDateTime &datetime);
+	void IgnoreDateChanged(int state);
+	void IgnoreTimeChanged(int state);
+	void RepeatChanged(int state);
+	void DurationChanged(double seconds);
+	void DurationUnitChanged(DurationUnit unit);
+signals:
+	void HeaderInfoChanged(const QString &);
+
+protected:
+	QComboBox *_condition;
+	QDateTimeEdit *_dateTime;
+	QDateTimeEdit *_dateTime2;
+	QCheckBox *_ignoreDate;
+	QCheckBox *_ignoreTime;
+	QCheckBox *_repeat;
+	DurationSelection *_duration;
+	std::shared_ptr<MacroConditionDate> _entryData;
+
+private:
+	void ShowSecondDateSelection(bool visible);
+	bool _loading = true;
+};

src/headers/macro-condition-edit.hpp

@@ -1,12 +1,5 @@
 #pragma once
-
-#include "advanced-scene-switcher.hpp"
 #include "macro.hpp"
-#include "macro-condition-scene.hpp"
-#include "section.hpp"
-#include "utility.hpp"
-
-#include <QGroupBox>
 
 struct MacroConditionInfo {
 	using TCreateMethod = std::shared_ptr<MacroCondition> (*)();
@@ -15,45 +8,51 @@ struct MacroConditionInfo {
 	TCreateMethod _createFunc;
 	TCreateWidgetMethod _createWidgetFunc;
 	std::string _name;
+	bool _useDurationConstraint = true;
 };
 
 class MacroConditionFactory {
 public:
 	MacroConditionFactory() = delete;
-	static bool Register(int id, MacroConditionInfo);
-	static std::shared_ptr<MacroCondition> Create(const int id);
-	static QWidget *CreateWidget(const int id, QWidget *parent,
+	static bool Register(const std::string &, MacroConditionInfo);
+	static std::shared_ptr<MacroCondition> Create(const std::string &);
+	static QWidget *CreateWidget(const std::string &id, QWidget *parent,
 				     std::shared_ptr<MacroCondition>);
 	static auto GetConditionTypes() { return _methods; }
+	static std::string GetConditionName(const std::string &);
+	static std::string GetIdByName(const QString &name);
+	static bool UsesDurationConstraint(const std::string &id);
 
 private:
-	static std::map<int, MacroConditionInfo> _methods;
+	static std::map<std::string, MacroConditionInfo> _methods;
 };
 
-class MacroConditionEdit : public QWidget {
+class MacroConditionEdit : public MacroSegmentEdit {
 	Q_OBJECT
 
 public:
 	MacroConditionEdit(QWidget *parent = nullptr,
 			   std::shared_ptr<MacroCondition> * = nullptr,
-			   int type = 0, bool root = true,
-			   bool startCollapsed = false);
+			   const std::string &id = "scene", bool root = true);
 	bool IsRootNode();
-	void UpdateEntryData(int type);
-	void Collapse(bool collapsed);
+	void SetRootNode(bool);
+	void UpdateEntryData(const std::string &id);
 
 private slots:
 	void LogicSelectionChanged(int idx);
-	void ConditionSelectionChanged(int idx);
-
-protected:
-	QComboBox *_logicSelection;
-	QComboBox *_conditionSelection;
-	Section *_section;
-
-	std::shared_ptr<MacroCondition> *_entryData;
+	void ConditionSelectionChanged(const QString &text);
+	void DurationChanged(double seconds);
+	void DurationConditionChanged(DurationCondition cond);
+	void DurationUnitChanged(DurationUnit unit);
 
 private:
+	MacroSegment *Data();
+
+	QComboBox *_logicSelection;
+	QComboBox *_conditionSelection;
+	DurationConstraintEdit *_dur;
+
+	std::shared_ptr<MacroCondition> *_entryData;
 	bool _isRoot = true;
 	bool _loading = true;
 };

src/headers/macro-condition-file.hpp

@@ -18,7 +18,8 @@ public:
 	bool CheckCondition();
 	bool Save(obs_data_t *obj);
 	bool Load(obs_data_t *obj);
-	int GetId() { return id; };
+	std::string GetShortDesc();
+	std::string GetId() { return id; };
 	static std::shared_ptr<MacroCondition> Create()
 	{
 		return std::make_shared<MacroConditionFile>();
@@ -39,7 +40,7 @@ private:
 	QDateTime _lastMod;
 	size_t _lastHash = 0;
 	static bool _registered;
-	static const int id;
+	static const std::string id;
 };
 
 class MacroConditionFileEdit : public QWidget {
@@ -66,6 +67,8 @@ private slots:
 	void UseRegexChanged(int state);
 	void CheckModificationDateChanged(int state);
 	void OnlyMatchIfChangedChanged(int state);
+signals:
+	void HeaderInfoChanged(const QString &);
 
 protected:
 	QComboBox *_fileType;

src/headers/macro-condition-filter.hpp

@@ -0,0 +1,77 @@
+#pragma once
+#include "macro.hpp"
+
+#include <QComboBox>
+#include <QPushButton>
+#include <QPlainTextEdit>
+#include <QCheckBox>
+
+enum class FilterCondition {
+	ENABLED,
+	DISABLED,
+	SETTINGS,
+};
+
+class MacroConditionFilter : public MacroCondition {
+public:
+	bool CheckCondition();
+	bool Save(obs_data_t *obj);
+	bool Load(obs_data_t *obj);
+	std::string GetShortDesc();
+	std::string GetId() { return id; };
+	static std::shared_ptr<MacroCondition> Create()
+	{
+		return std::make_shared<MacroConditionFilter>();
+	}
+
+	OBSWeakSource _source;
+	OBSWeakSource _filter;
+	FilterCondition _condition = FilterCondition::ENABLED;
+	std::string _settings = "";
+	bool _regex = false;
+
+private:
+	static bool _registered;
+	static const std::string id;
+};
+
+class MacroConditionFilterEdit : public QWidget {
+	Q_OBJECT
+
+public:
+	MacroConditionFilterEdit(
+		QWidget *parent,
+		std::shared_ptr<MacroConditionFilter> cond = nullptr);
+	void UpdateEntryData();
+	static QWidget *Create(QWidget *parent,
+			       std::shared_ptr<MacroCondition> cond)
+	{
+		return new MacroConditionFilterEdit(
+			parent,
+			std::dynamic_pointer_cast<MacroConditionFilter>(cond));
+	}
+
+private slots:
+	void SourceChanged(const QString &text);
+	void FilterChanged(const QString &text);
+	void ConditionChanged(int cond);
+	void GetSettingsClicked();
+	void SettingsChanged();
+	void RegexChanged(int);
+signals:
+	void HeaderInfoChanged(const QString &);
+
+protected:
+	QComboBox *_sources;
+	QComboBox *_filters;
+	QComboBox *_conditions;
+	QPushButton *_getSettings;
+	QPlainTextEdit *_settings;
+	QCheckBox *_regex;
+
+	std::shared_ptr<MacroConditionFilter> _entryData;
+
+private:
+	void SetSettingsSelectionVisible(bool visible);
+	bool _loading = true;
+};

src/headers/macro-condition-hotkey.hpp

@@ -0,0 +1,54 @@
+#pragma once
+#include "macro.hpp"
+#include <QWidget>
+#include <QLineEdit>
+
+class MacroConditionHotkey : public MacroCondition {
+public:
+	MacroConditionHotkey();
+	~MacroConditionHotkey();
+	bool CheckCondition();
+	bool Save(obs_data_t *obj);
+	bool Load(obs_data_t *obj);
+	std::string GetId() { return id; };
+	static std::shared_ptr<MacroCondition> Create()
+	{
+		return std::make_shared<MacroConditionHotkey>();
+	}
+	void SetPressed() { _pressed = true; }
+
+	std::string _name;
+	obs_hotkey_id _hotkeyID = OBS_INVALID_HOTKEY_ID;
+
+private:
+	bool _pressed = false;
+	static bool _registered;
+	static const std::string id;
+};
+
+class MacroConditionHotkeyEdit : public QWidget {
+	Q_OBJECT
+
+public:
+	MacroConditionHotkeyEdit(
+		QWidget *parent,
+		std::shared_ptr<MacroConditionHotkey> cond = nullptr);
+	void UpdateEntryData();
+	static QWidget *Create(QWidget *parent,
+			       std::shared_ptr<MacroCondition> cond)
+	{
+		return new MacroConditionHotkeyEdit(
+			parent,
+			std::dynamic_pointer_cast<MacroConditionHotkey>(cond));
+	}
+
+private slots:
+	void NameChanged();
+
+protected:
+	QLineEdit *_name;
+	std::shared_ptr<MacroConditionHotkey> _entryData;
+
+private:
+	bool _loading = true;
+};

src/headers/macro-condition-idle.hpp

@@ -1,15 +1,16 @@
 #pragma once
 #include "macro.hpp"
+#include "duration-control.hpp"
+
 #include <QWidget>
 #include <QComboBox>
-#include "duration-control.hpp"
 
 class MacroConditionIdle : public MacroCondition {
 public:
 	bool CheckCondition();
 	bool Save(obs_data_t *obj);
 	bool Load(obs_data_t *obj);
-	int GetId() { return id; };
+	std::string GetId() { return id; };
 	static std::shared_ptr<MacroCondition> Create()
 	{
 		return std::make_shared<MacroConditionIdle>();
@@ -19,7 +20,7 @@ public:
 
 private:
 	static bool _registered;
-	static const int id;
+	static const std::string id;
 };
 
 class MacroConditionIdleEdit : public QWidget {

src/headers/macro-condition-macro.hpp

@@ -0,0 +1,91 @@
+#pragma once
+#include "macro.hpp"
+#include "macro-selection.hpp"
+
+#include <QComboBox>
+#include <QSpinBox>
+#include <QPushButton>
+#include <QHBoxLayout>
+#include <QTimer>
+
+enum class MacroConditionMacroType {
+	COUNT,
+	STATE,
+};
+
+enum class CounterCondition {
+	BELOW,
+	ABOVE,
+	EQUAL,
+};
+
+class MacroConditionMacro : public MacroRefCondition {
+public:
+	bool CheckCondition();
+	bool Save(obs_data_t *obj);
+	bool Load(obs_data_t *obj);
+	std::string GetShortDesc();
+	std::string GetId() { return id; };
+	static std::shared_ptr<MacroCondition> Create()
+	{
+		return std::make_shared<MacroConditionMacro>();
+	}
+
+	MacroConditionMacroType _type = MacroConditionMacroType::STATE;
+	CounterCondition _counterCondition = CounterCondition::BELOW;
+	int _count = 0;
+
+private:
+	bool CheckCountCondition();
+	bool CheckStateCondition();
+
+	static bool _registered;
+	static const std::string id;
+};
+
+class MacroConditionMacroEdit : public QWidget {
+	Q_OBJECT
+
+public:
+	MacroConditionMacroEdit(
+		QWidget *parent,
+		std::shared_ptr<MacroConditionMacro> cond = nullptr);
+	void UpdateEntryData();
+	static QWidget *Create(QWidget *parent,
+			       std::shared_ptr<MacroCondition> cond)
+	{
+		return new MacroConditionMacroEdit(
+			parent,
+			std::dynamic_pointer_cast<MacroConditionMacro>(cond));
+	}
+
+private slots:
+	void MacroChanged(const QString &text);
+	void MacroRemove(const QString &name);
+	void TypeChanged(int type);
+	void CountChanged(int value);
+	void ConditionChanged(int cond);
+	void ResetClicked();
+	void UpdateCount();
+signals:
+	void HeaderInfoChanged(const QString &);
+
+protected:
+	MacroSelection *_macros;
+	QComboBox *_types;
+	QComboBox *_counterConditions;
+	QSpinBox *_count;
+	QLabel *_currentCount;
+	QPushButton *_resetCount;
+	QHBoxLayout *_settingsLine1;
+	QHBoxLayout *_settingsLine2;
+	std::unique_ptr<QTimer> _timer;
+	std::shared_ptr<MacroConditionMacro> _entryData;
+
+private:
+	void ClearLayouts();
+	void SetupStateWidgets();
+	void SetupCountWidgets();
+	void ResetTimer();
+	bool _loading = true;
+};

src/headers/macro-condition-media.hpp

@@ -39,7 +39,8 @@ public:
 	bool CheckCondition();
 	bool Save(obs_data_t *obj);
 	bool Load(obs_data_t *obj);
-	int GetId() { return id; };
+	std::string GetShortDesc();
+	std::string GetId() { return id; };
 	static std::shared_ptr<MacroCondition> Create()
 	{
 		return std::make_shared<MacroConditionMedia>();
@@ -65,7 +66,7 @@ private:
 	bool _playedToEnd = false;
 
 	static bool _registered;
-	static const int id;
+	static const std::string id;
 };
 
 class MacroConditionMediaEdit : public QWidget {
@@ -90,6 +91,8 @@ private slots:
 	void TimeRestrictionChanged(int index);
 	void TimeChanged(double seconds);
 	void TimeUnitChanged(DurationUnit unit);
+signals:
+	void HeaderInfoChanged(const QString &);
 
 protected:
 	QComboBox *_mediaSources;

src/headers/macro-condition-plugin-state.hpp

@@ -12,7 +12,7 @@ public:
 	bool CheckCondition();
 	bool Save(obs_data_t *obj);
 	bool Load(obs_data_t *obj);
-	int GetId() { return id; };
+	std::string GetId() { return id; };
 	static std::shared_ptr<MacroCondition> Create()
 	{
 		return std::make_shared<MacroConditionPluginState>();
@@ -22,7 +22,7 @@ public:
 
 private:
 	static bool _registered;
-	static const int id;
+	static const std::string id;
 };
 
 class MacroConditionPluginStateEdit : public QWidget {

src/headers/macro-condition-process.hpp

@@ -1,14 +1,16 @@
 #pragma once
 #include "macro.hpp"
-#include <QWidget>
+
 #include <QComboBox>
+#include <QCheckBox>
 
 class MacroConditionProcess : public MacroCondition {
 public:
 	bool CheckCondition();
 	bool Save(obs_data_t *obj);
 	bool Load(obs_data_t *obj);
-	int GetId() { return id; };
+	std::string GetShortDesc();
+	std::string GetId() { return id; };
 	static std::shared_ptr<MacroCondition> Create()
 	{
 		return std::make_shared<MacroConditionProcess>();
@@ -19,7 +21,7 @@ public:
 
 private:
 	static bool _registered;
-	static const int id;
+	static const std::string id;
 };
 
 class MacroConditionProcessEdit : public QWidget {
@@ -41,6 +43,8 @@ public:
 private slots:
 	void ProcessChanged(const QString &text);
 	void FocusChanged(int state);
+signals:
+	void HeaderInfoChanged(const QString &);
 
 protected:
 	QComboBox *_processSelection;

src/headers/macro-condition-recording.hpp

@@ -2,7 +2,6 @@
 #include "macro.hpp"
 #include <QWidget>
 #include <QComboBox>
-#include "duration-control.hpp"
 
 enum class RecordState {
 	STOP,
@@ -15,18 +14,17 @@ public:
 	bool CheckCondition();
 	bool Save(obs_data_t *obj);
 	bool Load(obs_data_t *obj);
-	int GetId() { return id; };
+	std::string GetId() { return id; };
 	static std::shared_ptr<MacroCondition> Create()
 	{
 		return std::make_shared<MacroConditionRecord>();
 	}
 
 	RecordState _recordState;
-	Duration _duration;
 
 private:
 	static bool _registered;
-	static const int id;
+	static const std::string id;
 };
 
 class MacroConditionRecordEdit : public QWidget {
@@ -47,12 +45,9 @@ public:
 
 private slots:
 	void StateChanged(int value);
-	void DurationChanged(double seconds);
-	void DurationUnitChanged(DurationUnit unit);
 
 protected:
 	QComboBox *_recordState;
-	DurationSelection *_duration;
 	std::shared_ptr<MacroConditionRecord> _entryData;
 
 private:

src/headers/macro-condition-region.hpp

@@ -1,55 +0,0 @@
-#pragma once
-#include "macro.hpp"
-#include <QWidget>
-#include <QComboBox>
-
-class MacroConditionRegion : public MacroCondition {
-public:
-	bool CheckCondition();
-	bool Save(obs_data_t *obj);
-	bool Load(obs_data_t *obj);
-	int GetId() { return id; };
-	static std::shared_ptr<MacroCondition> Create()
-	{
-		return std::make_shared<MacroConditionRegion>();
-	}
-
-	int _minX = 0, _minY = 0, _maxX = 0, _maxY = 0;
-
-private:
-	static bool _registered;
-	static const int id;
-};
-
-class MacroConditionRegionEdit : public QWidget {
-	Q_OBJECT
-
-public:
-	MacroConditionRegionEdit(
-		QWidget *parent,
-		std::shared_ptr<MacroConditionRegion> cond = nullptr);
-	void UpdateEntryData();
-	static QWidget *Create(QWidget *parent,
-			       std::shared_ptr<MacroCondition> cond)
-	{
-		return new MacroConditionRegionEdit(
-			parent,
-			std::dynamic_pointer_cast<MacroConditionRegion>(cond));
-	}
-
-private slots:
-	void MinXChanged(int pos);
-	void MinYChanged(int pos);
-	void MaxXChanged(int pos);
-	void MaxYChanged(int pos);
-
-protected:
-	QSpinBox *_minX;
-	QSpinBox *_minY;
-	QSpinBox *_maxX;
-	QSpinBox *_maxY;
-	std::shared_ptr<MacroConditionRegion> _entryData;
-
-private:
-	bool _loading = true;
-};

src/headers/macro-condition-replay-buffer.hpp

@@ -0,0 +1,56 @@
+#pragma once
+#include "macro.hpp"
+#include <QWidget>
+#include <QComboBox>
+
+enum class ReplayBufferState {
+	STOP,
+	START,
+	SAVE,
+};
+
+class MacroConditionReplayBuffer : public MacroCondition {
+public:
+	bool CheckCondition();
+	bool Save(obs_data_t *obj);
+	bool Load(obs_data_t *obj);
+	std::string GetId() { return id; };
+	static std::shared_ptr<MacroCondition> Create()
+	{
+		return std::make_shared<MacroConditionReplayBuffer>();
+	}
+
+	ReplayBufferState _state;
+
+private:
+	static bool _registered;
+	static const std::string id;
+};
+
+class MacroConditionReplayBufferEdit : public QWidget {
+	Q_OBJECT
+
+public:
+	MacroConditionReplayBufferEdit(
+		QWidget *parent,
+		std::shared_ptr<MacroConditionReplayBuffer> cond = nullptr);
+	void UpdateEntryData();
+	static QWidget *Create(QWidget *parent,
+			       std::shared_ptr<MacroCondition> cond)
+	{
+		return new MacroConditionReplayBufferEdit(
+			parent,
+			std::dynamic_pointer_cast<MacroConditionReplayBuffer>(
+				cond));
+	}
+
+private slots:
+	void StateChanged(int value);
+
+protected:
+	QComboBox *_state;
+	std::shared_ptr<MacroConditionReplayBuffer> _entryData;
+
+private:
+	bool _loading = true;
+};

src/headers/macro-condition-scene-order.hpp

@@ -0,0 +1,76 @@
+#pragma once
+#include "macro.hpp"
+#include "scene-selection.hpp"
+
+#include <QWidget>
+#include <QComboBox>
+
+enum class SceneOrderCondition {
+	ABOVE,
+	BELOW,
+	POSITION,
+};
+
+class MacroConditionSceneOrder : public MacroCondition {
+public:
+	bool CheckCondition();
+	bool Save(obs_data_t *obj);
+	bool Load(obs_data_t *obj);
+	std::string GetShortDesc();
+	std::string GetId() { return id; };
+	static std::shared_ptr<MacroCondition> Create()
+	{
+		return std::make_shared<MacroConditionSceneOrder>();
+	}
+
+	SceneSelection _scene;
+	OBSWeakSource _source;
+	OBSWeakSource _source2;
+	int _position = 0;
+	SceneOrderCondition _condition = SceneOrderCondition::ABOVE;
+
+private:
+	static bool _registered;
+	static const std::string id;
+};
+
+class MacroConditionSceneOrderEdit : public QWidget {
+	Q_OBJECT
+
+public:
+	MacroConditionSceneOrderEdit(
+		QWidget *parent,
+		std::shared_ptr<MacroConditionSceneOrder> cond = nullptr);
+	void UpdateEntryData();
+	static QWidget *Create(QWidget *parent,
+			       std::shared_ptr<MacroCondition> cond)
+	{
+		return new MacroConditionSceneOrderEdit(
+			parent,
+			std::dynamic_pointer_cast<MacroConditionSceneOrder>(
+				cond));
+	}
+
+private slots:
+	void SceneChanged(const SceneSelection &);
+	void SourceChanged(const QString &text);
+	void Source2Changed(const QString &text);
+	void ConditionChanged(int cond);
+	void PositionChanged(int cond);
+signals:
+	void HeaderInfoChanged(const QString &);
+
+protected:
+	SceneSelectionWidget *_scenes;
+	QComboBox *_conditions;
+	QComboBox *_sources;
+	QComboBox *_sources2;
+	QSpinBox *_position;
+	QLabel *_posInfo;
+
+	std::shared_ptr<MacroConditionSceneOrder> _entryData;
+
+private:
+	void SetWidgetVisibility(bool showPos);
+	bool _loading = true;
+};

src/headers/macro-condition-scene.hpp

@@ -1,8 +1,9 @@
 #pragma once
 #include "macro.hpp"
+#include "scene-selection.hpp"
+
 #include <QWidget>
 #include <QComboBox>
-#include "duration-control.hpp"
 
 enum class SceneType {
 	CURRENT,
@@ -14,19 +15,19 @@ public:
 	bool CheckCondition();
 	bool Save(obs_data_t *obj);
 	bool Load(obs_data_t *obj);
-	int GetId() { return id; };
+	std::string GetShortDesc();
+	std::string GetId() { return id; };
 	static std::shared_ptr<MacroCondition> Create()
 	{
 		return std::make_shared<MacroConditionScene>();
 	}
 
-	OBSWeakSource _scene;
+	SceneSelection _scene;
 	SceneType _type;
-	Duration _duration;
 
 private:
 	static bool _registered;
-	static const int id;
+	static const std::string id;
 };
 
 class MacroConditionSceneEdit : public QWidget {
@@ -46,15 +47,14 @@ public:
 	}
 
 private slots:
-	void SceneChanged(const QString &text);
+	void SceneChanged(const SceneSelection &);
 	void TypeChanged(int value);
-	void DurationChanged(double seconds);
-	void DurationUnitChanged(DurationUnit unit);
+signals:
+	void HeaderInfoChanged(const QString &);
 
 protected:
-	QComboBox *_sceneSelection;
+	SceneSelectionWidget *_scenes;
 	QComboBox *_sceneType;
-	DurationSelection *_duration;
 	std::shared_ptr<MacroConditionScene> _entryData;
 
 private:

src/headers/macro-condition-source.hpp

@@ -0,0 +1,74 @@
+#pragma once
+#include "macro.hpp"
+
+#include <QComboBox>
+#include <QPushButton>
+#include <QPlainTextEdit>
+#include <QCheckBox>
+
+enum class SourceCondition {
+	ACTIVE,
+	SHOWING,
+	SETTINGS,
+};
+
+class MacroConditionSource : public MacroCondition {
+public:
+	bool CheckCondition();
+	bool Save(obs_data_t *obj);
+	bool Load(obs_data_t *obj);
+	std::string GetShortDesc();
+	std::string GetId() { return id; };
+	static std::shared_ptr<MacroCondition> Create()
+	{
+		return std::make_shared<MacroConditionSource>();
+	}
+
+	OBSWeakSource _source = nullptr;
+	SourceCondition _condition = SourceCondition::ACTIVE;
+	std::string _settings = "";
+	bool _regex = false;
+
+private:
+	static bool _registered;
+	static const std::string id;
+};
+
+class MacroConditionSourceEdit : public QWidget {
+	Q_OBJECT
+
+public:
+	MacroConditionSourceEdit(
+		QWidget *parent,
+		std::shared_ptr<MacroConditionSource> cond = nullptr);
+	void UpdateEntryData();
+	static QWidget *Create(QWidget *parent,
+			       std::shared_ptr<MacroCondition> cond)
+	{
+		return new MacroConditionSourceEdit(
+			parent,
+			std::dynamic_pointer_cast<MacroConditionSource>(cond));
+	}
+
+private slots:
+	void SourceChanged(const QString &text);
+	void ConditionChanged(int cond);
+	void GetSettingsClicked();
+	void SettingsChanged();
+	void RegexChanged(int);
+signals:
+	void HeaderInfoChanged(const QString &);
+
+protected:
+	QComboBox *_sources;
+	QComboBox *_conditions;
+	QPushButton *_getSettings;
+	QPlainTextEdit *_settings;
+	QCheckBox *_regex;
+
+	std::shared_ptr<MacroConditionSource> _entryData;
+
+private:
+	void SetSettingsSelectionVisible(bool visible);
+	bool _loading = true;
+};

src/headers/macro-condition-streaming.hpp

@@ -2,7 +2,6 @@
 #include "macro.hpp"
 #include <QWidget>
 #include <QComboBox>
-#include "duration-control.hpp"
 
 enum class StreamState {
 	STOP,
@@ -14,18 +13,17 @@ public:
 	bool CheckCondition();
 	bool Save(obs_data_t *obj);
 	bool Load(obs_data_t *obj);
-	int GetId() { return id; };
+	std::string GetId() { return id; };
 	static std::shared_ptr<MacroCondition> Create()
 	{
 		return std::make_shared<MacroConditionStream>();
 	}
 
 	StreamState _streamState;
-	Duration _duration;
 
 private:
 	static bool _registered;
-	static const int id;
+	static const std::string id;
 };
 
 class MacroConditionStreamEdit : public QWidget {
@@ -46,12 +44,9 @@ public:
 
 private slots:
 	void StateChanged(int value);
-	void DurationChanged(double seconds);
-	void DurationUnitChanged(DurationUnit unit);
 
 protected:
 	QComboBox *_streamState;
-	DurationSelection *_duration;
 	std::shared_ptr<MacroConditionStream> _entryData;
 
 private:

src/headers/macro-condition-timer.hpp

@@ -0,0 +1,61 @@
+#pragma once
+#include "macro.hpp"
+#include "duration-control.hpp"
+
+#include <QCheckBox>
+#include <QPushButton>
+#include <QTimer>
+
+class MacroConditionTimer : public MacroCondition {
+public:
+	bool CheckCondition();
+	bool Save(obs_data_t *obj);
+	bool Load(obs_data_t *obj);
+	std::string GetId() { return id; };
+	static std::shared_ptr<MacroCondition> Create()
+	{
+		return std::make_shared<MacroConditionTimer>();
+	}
+
+	Duration _duration;
+	bool _oneshot = false;
+
+private:
+	static bool _registered;
+	static const std::string id;
+};
+
+class MacroConditionTimerEdit : public QWidget {
+	Q_OBJECT
+
+public:
+	MacroConditionTimerEdit(
+		QWidget *parent,
+		std::shared_ptr<MacroConditionTimer> cond = nullptr);
+	void UpdateEntryData();
+	static QWidget *Create(QWidget *parent,
+			       std::shared_ptr<MacroCondition> cond)
+	{
+		return new MacroConditionTimerEdit(
+			parent,
+			std::dynamic_pointer_cast<MacroConditionTimer>(cond));
+	}
+
+private slots:
+	void DurationChanged(double seconds);
+	void DurationUnitChanged(DurationUnit unit);
+	void AutoResetChanged(int state);
+	void ResetClicked();
+	void UpdateTimeRemaining();
+
+protected:
+	DurationSelection *_duration;
+	QCheckBox *_autoReset;
+	QPushButton *_reset;
+	QLabel *_remaining;
+	std::shared_ptr<MacroConditionTimer> _entryData;
+
+private:
+	QTimer timer;
+	bool _loading = true;
+};

src/headers/macro-condition-video.hpp

@@ -1,10 +1,10 @@
 #pragma once
 #include "macro.hpp"
+#include "screenshot-helper.hpp"
+
 #include <QWidget>
 #include <QComboBox>
 #include <chrono>
-#include "duration-control.hpp"
-#include "screenshot-helper.hpp"
 
 enum class VideoCondition {
 	MATCH,
@@ -19,7 +19,8 @@ public:
 	bool CheckCondition();
 	bool Save(obs_data_t *obj);
 	bool Load(obs_data_t *obj);
-	int GetId() { return id; };
+	std::string GetShortDesc();
+	std::string GetId() { return id; };
 	QImage GetMatchImage() { return _matchImage; };
 	static std::shared_ptr<MacroCondition> Create()
 	{
@@ -30,7 +31,6 @@ public:
 
 	OBSWeakSource _videoSource;
 	VideoCondition _condition = VideoCondition::MATCH;
-	Duration _duration;
 	std::string _file = obs_module_text("AdvSceneSwitcher.enterPath");
 
 private:
@@ -39,7 +39,7 @@ private:
 	std::unique_ptr<AdvSSScreenshotObj> _screenshotData = nullptr;
 	QImage _matchImage;
 	static bool _registered;
-	static const int id;
+	static const std::string id;
 };
 
 class MacroConditionVideoEdit : public QWidget {
@@ -66,12 +66,11 @@ private slots:
 	void ConditionChanged(int cond);
 	void FilePathChanged();
 	void BrowseButtonClicked();
-	void DurationChanged(double seconds);
-	void DurationUnitChanged(DurationUnit unit);
+signals:
+	void HeaderInfoChanged(const QString &);
 
 protected:
 	QComboBox *_videoSelection;
-	DurationSelection *_duration;
 	QComboBox *_condition;
 	QLineEdit *_filePath;
 	QPushButton *_browseButton;

src/headers/macro-condition-virtual-cam.hpp

@@ -0,0 +1,54 @@
+#pragma once
+#include "macro.hpp"
+#include <QWidget>
+#include <QComboBox>
+
+enum class VCamState {
+	STOP,
+	START,
+};
+
+class MacroConditionVCam : public MacroCondition {
+public:
+	bool CheckCondition();
+	bool Save(obs_data_t *obj);
+	bool Load(obs_data_t *obj);
+	std::string GetId() { return id; };
+	static std::shared_ptr<MacroCondition> Create()
+	{
+		return std::make_shared<MacroConditionVCam>();
+	}
+
+	VCamState _state;
+
+private:
+	static bool _registered;
+	static const std::string id;
+};
+
+class MacroConditionVCamEdit : public QWidget {
+	Q_OBJECT
+
+public:
+	MacroConditionVCamEdit(
+		QWidget *parent,
+		std::shared_ptr<MacroConditionVCam> cond = nullptr);
+	void UpdateEntryData();
+	static QWidget *Create(QWidget *parent,
+			       std::shared_ptr<MacroCondition> cond)
+	{
+		return new MacroConditionVCamEdit(
+			parent,
+			std::dynamic_pointer_cast<MacroConditionVCam>(cond));
+	}
+
+private slots:
+	void StateChanged(int value);
+
+protected:
+	QComboBox *_states;
+	std::shared_ptr<MacroConditionVCam> _entryData;
+
+private:
+	bool _loading = true;
+};

src/headers/macro-condition-window.hpp

@@ -1,14 +1,16 @@
 #pragma once
 #include "macro.hpp"
-#include <QWidget>
+
 #include <QComboBox>
+#include <QCheckBox>
 
 class MacroConditionWindow : public MacroCondition {
 public:
 	bool CheckCondition();
 	bool Save(obs_data_t *obj);
 	bool Load(obs_data_t *obj);
-	int GetId() { return id; };
+	std::string GetShortDesc();
+	std::string GetId() { return id; };
 	static std::shared_ptr<MacroCondition> Create()
 	{
 		return std::make_shared<MacroConditionWindow>();
@@ -24,10 +26,11 @@ public:
 	bool _fullscreen = false;
 	bool _maximized = false;
 	bool _focus = true;
+	bool _windowFocusChanged = false;
 
 private:
 	static bool _registered;
-	static const int id;
+	static const std::string id;
 };
 
 class MacroConditionWindowEdit : public QWidget {
@@ -50,13 +53,17 @@ private slots:
 	void WindowChanged(const QString &text);
 	void FullscreenChanged(int state);
 	void MaximizedChanged(int state);
-	void FocusChanged(int state);
+	void FocusedChanged(int state);
+	void WindowFocusChanged(int state);
+signals:
+	void HeaderInfoChanged(const QString &);
 
 protected:
 	QComboBox *_windowSelection;
 	QCheckBox *_fullscreen;
 	QCheckBox *_maximized;
 	QCheckBox *_focused;
+	QCheckBox *_windowFocusChanged;
 	std::shared_ptr<MacroConditionWindow> _entryData;
 
 private:

src/headers/macro-controls.hpp

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <QFrame>
+#include <QPropertyAnimation>
+#include <QScrollArea>
+#include <QPushButton>
+#include <QLayout>
+#include <QWidget>
+
+class MacroEntryControls : public QWidget {
+	Q_OBJECT
+
+public:
+	explicit MacroEntryControls(const int animationDuration = 300,
+				    QWidget *parent = 0);
+
+	void Show(bool visible = true);
+
+signals:
+	void Add();
+	void Remove();
+	void Up();
+	void Down();
+
+private:
+	QPushButton *_add;
+	QPushButton *_remove;
+	QPushButton *_up;
+	QPushButton *_down;
+	QPropertyAnimation *_animation = nullptr;
+};

src/headers/macro-segment.hpp

@@ -0,0 +1,71 @@
+#pragma once
+#include <QWidget>
+#include <obs.hpp>
+
+class MacroSegment {
+public:
+	void SetIndex(int idx) { _idx = idx; }
+	int GetIndex() { return _idx; }
+	void SetCollapsed(bool collapsed) { _collapsed = collapsed; }
+	bool GetCollapsed() { return _collapsed; }
+	virtual bool Save(obs_data_t *obj) = 0;
+	virtual bool Load(obs_data_t *obj) = 0;
+	virtual std::string GetShortDesc();
+	virtual std::string GetId() = 0;
+
+protected:
+	int _idx;
+	bool _collapsed = false;
+};
+
+class Section;
+class QLabel;
+class MacroEntryControls;
+
+class MacroSegmentEdit : public QWidget {
+	Q_OBJECT
+
+public:
+	MacroSegmentEdit(QWidget *parent = nullptr);
+	// Use this function to avoid accidental edits when scrolling through
+	// list of actions and conditions
+	void SetFocusPolicyOfWidgets();
+
+protected slots:
+	void HeaderInfoChanged(const QString &);
+	void Add();
+	void Remove();
+	void Up();
+	void Down();
+	void Collapsed(bool);
+signals:
+	void MacroAdded(const QString &name);
+	void MacroRemoved(const QString &name);
+	void MacroRenamed(const QString &oldName, const QString newName);
+	void SceneGroupAdded(const QString &name);
+	void SceneGroupRemoved(const QString &name);
+	void SceneGroupRenamed(const QString &oldName, const QString newName);
+	void AddAt(int idx);
+	void RemoveAt(int idx);
+	void UpAt(int idx);
+	void DownAt(int idx);
+
+protected:
+	void enterEvent(QEvent *e);
+	void leaveEvent(QEvent *e);
+
+	Section *_section;
+	QLabel *_headerInfo;
+	MacroEntryControls *_controls;
+
+private:
+	virtual MacroSegment *Data() = 0;
+};
+
+class MouseWheelWidgetAdjustmentGuard : public QObject {
+public:
+	explicit MouseWheelWidgetAdjustmentGuard(QObject *parent);
+
+protected:
+	bool eventFilter(QObject *o, QEvent *e) override;
+};

src/headers/macro-selection.hpp

@@ -0,0 +1,17 @@
+#pragma once
+#include <QComboBox>
+
+class Macro;
+
+class MacroSelection : public QComboBox {
+	Q_OBJECT
+
+public:
+	MacroSelection(QWidget *parent);
+	void SetCurrentMacro(Macro *);
+
+private slots:
+	void MacroAdd(const QString &name);
+	void MacroRemove(const QString &name);
+	void MacroRename(const QString &oldName, const QString &newName);
+};

src/headers/macro.hpp

@@ -1,10 +1,14 @@
 #pragma once
+#include "macro-segment.hpp"
+#include "duration-control.hpp"
+
 #include <string>
 #include <deque>
 #include <memory>
 #include <map>
 #include <obs.hpp>
 #include <obs-module.h>
+#include <QString>
 
 constexpr auto macro_func = 10;
 constexpr auto default_priority_10 = macro_func;
@@ -33,56 +37,110 @@ struct LogicTypeInfo {
 	std::string _name;
 };
 
-class MacroCondition {
+class MacroCondition : public MacroSegment {
 public:
 	virtual bool CheckCondition() = 0;
 	virtual bool Save(obs_data_t *obj) = 0;
 	virtual bool Load(obs_data_t *obj) = 0;
-	virtual int GetId() = 0;
 	LogicType GetLogicType() { return _logic; }
 	void SetLogicType(LogicType logic) { _logic = logic; }
-
 	static const std::map<LogicType, LogicTypeInfo> logicTypes;
 
+	bool DurationReached() { return _duration.DurationReached(); }
+	void ResetDuration() { _duration.Reset(); }
+	DurationConstraint GetDurationConstraint() { return _duration; }
+	void SetDurationConstraint(const DurationConstraint &dur);
+	void SetDurationCondition(DurationCondition cond);
+	void SetDurationUnit(DurationUnit u);
+	void SetDuration(double seconds);
+
 private:
 	LogicType _logic;
+	DurationConstraint _duration;
 };
 
-class MacroAction {
+class MacroAction : public MacroSegment {
 public:
 	virtual bool PerformAction() = 0;
 	virtual bool Save(obs_data_t *obj) = 0;
 	virtual bool Load(obs_data_t *obj) = 0;
-	virtual int GetId() = 0;
 	virtual void LogAction();
 };
 
 class Macro {
-
 public:
-	Macro(std::string name = "");
+	Macro(const std::string &name = "");
 	virtual ~Macro();
 
 	bool CeckMatch();
 	bool PerformAction();
 	bool Matched() { return _matched; }
 	std::string Name() { return _name; }
-	void SetName(std::string name) { _name = name; }
+	void SetName(const std::string &name);
+	void SetPaused(bool pause = true) { _paused = pause; }
+	bool Paused() { return _paused; }
+	int GetCount() { return _count; };
+	void ResetCount() { _count = 0; };
 	std::deque<std::shared_ptr<MacroCondition>> &Conditions()
 	{
 		return _conditions;
 	}
+	void UpdateActionIndices();
+	void UpdateConditionIndices();
 	std::deque<std::shared_ptr<MacroAction>> &Actions() { return _actions; }
 
 	bool Save(obs_data_t *obj);
 	bool Load(obs_data_t *obj);
+	// Some macros can refer to other macros, which are not yet loaded.
+	// Use this function to set these references after loading is complete.
+	void ResolveMacroRef();
 
 	// Helper function for plugin state condition regarding scene change
 	bool SwitchesScene();
 
 private:
+	void SetupHotkeys();
+	void ClearHotkeys();
+	void SetHotkeysDesc();
+
 	std::string _name = "";
 	std::deque<std::shared_ptr<MacroCondition>> _conditions;
 	std::deque<std::shared_ptr<MacroAction>> _actions;
 	bool _matched = false;
+	bool _paused = false;
+	int _count = 0;
+	obs_hotkey_id _pauseHotkey = OBS_INVALID_HOTKEY_ID;
+	obs_hotkey_id _unpauseHotkey = OBS_INVALID_HOTKEY_ID;
+};
+
+Macro *GetMacroByName(const char *name);
+Macro *GetMacroByQString(const QString &name);
+
+class MacroRef {
+public:
+	MacroRef(){};
+	MacroRef(std::string name);
+	void UpdateRef();
+	void UpdateRef(std::string name);
+	void UpdateRef(QString name);
+	void Save(obs_data_t *obj);
+	void Load(obs_data_t *obj);
+	Macro *get();
+	Macro *operator->();
+
+private:
+	std::string _name = "";
+	Macro *_ref = nullptr;
+};
+
+class MacroRefCondition : public MacroCondition {
+public:
+	void ResolveMacroRef();
+	MacroRef _macro;
+};
+
+class MacroRefAction : public MacroAction {
+public:
+	void ResolveMacroRef();
+	MacroRef _macro;
 };

src/headers/name-dialog.hpp

@@ -16,7 +16,7 @@ public:
 	static bool AskForName(QWidget *parent, const QString &title,
 			       const QString &text, std::string &userTextInput,
 			       const QString &placeHolder = QString(""),
-			       int maxSize = 170);
+			       int maxSize = 170, bool clean = true);
 
 private:
 	QLabel *label;

src/headers/platform-funcs.hpp

@@ -0,0 +1,15 @@
+#pragma once
+#include "hotkey.hpp"
+
+void GetWindowList(std::vector<std::string> &windows);
+void GetWindowList(QStringList &windows);
+void GetCurrentWindowTitle(std::string &title);
+bool isFullscreen(const std::string &title);
+bool isMaximized(const std::string &title);
+std::pair<int, int> getCursorPos();
+int secondsSinceLastInput();
+void GetProcessList(QStringList &processes);
+bool isInFocus(const QString &executable);
+void PressKeys(const std::vector<HotkeyType> keys);
+void PlatformInit();
+void PlatformCleanup();

src/headers/scene-group.hpp

@@ -40,9 +40,9 @@ struct SceneGroup {
 	int lastRandomScene = -1;
 
 	inline SceneGroup(){};
-	inline SceneGroup(std::string name_) : name(name_){};
-	inline SceneGroup(std::string name_, AdvanceCondition type_,
-			  std::vector<OBSWeakSource> scenes_, int count_,
+	inline SceneGroup(const std::string &name_) : name(name_){};
+	inline SceneGroup(const std::string &name_, AdvanceCondition type_,
+			  const std::vector<OBSWeakSource> &scenes_, int count_,
 			  double time_, bool repeat_)
 		: name(name_),
 		  type(type_),
@@ -82,3 +82,6 @@ private:
 
 	SceneGroup *sceneGroup = nullptr;
 };
+
+SceneGroup *GetSceneGroupByName(const char *name);
+SceneGroup *GetSceneGroupByQString(const QString &name);

src/headers/scene-selection.hpp

@@ -0,0 +1,51 @@
+#pragma once
+#include "scene-group.hpp"
+#include "utility.hpp"
+
+#include <QComboBox>
+
+enum class SceneSelectionType {
+	SCENE,
+	GROUP,
+	PREVIOUS,
+	CURRENT,
+};
+
+class SceneSelection {
+public:
+	void Save(obs_data_t *obj, const char *name = "scene",
+		  const char *typeName = "sceneType");
+	void Load(obs_data_t *obj, const char *name = "scene",
+		  const char *typeName = "sceneType");
+
+	SceneSelectionType GetType() { return _type; }
+	OBSWeakSource GetScene(bool advance = true);
+	std::string ToString();
+
+private:
+	OBSWeakSource _scene;
+	SceneGroup *_group = nullptr;
+	SceneSelectionType _type = SceneSelectionType::SCENE;
+	friend class SceneSelectionWidget;
+};
+
+class SceneSelectionWidget : public QComboBox {
+	Q_OBJECT
+
+public:
+	SceneSelectionWidget(QWidget *parent, bool sceneGroups = false,
+			     bool previous = false, bool current = false);
+	void SetScene(SceneSelection &);
+signals:
+	void SceneChanged(const SceneSelection &);
+
+private slots:
+	void SelectionChanged(const QString &name);
+	void SceneGroupAdd(const QString &name);
+	void SceneGroupRemove(const QString &name);
+	void SceneGroupRename(const QString &oldName, const QString &newName);
+
+private:
+	bool IsCurrentSceneSelected(const QString &name);
+	bool IsPreviousSceneSelected(const QString &name);
+};

src/headers/scene-trigger.hpp

@@ -1,3 +1,10 @@
+/******************************************************************************
+    Note: Long-term goal is to remove this tab / file.
+    Most functionality shall be moved to the Macro tab instead.
+
+    So if you plan to make changes here, please consider applying them to the
+    corresponding macro tab functionality instead.
+******************************************************************************/
 #pragma once
 
 #include "switch-generic.hpp"
@@ -27,6 +34,9 @@ enum class sceneTriggerAction {
 
 	START_SWITCHER,
 	STOP_SWITCHER,
+
+	START_VCAM,
+	STOP_VCAM,
 };
 
 struct SceneTrigger : SceneSwitcherEntry {

src/headers/section.hpp

@@ -14,18 +14,33 @@ public:
 	explicit Section(const int animationDuration = 300,
 			 QWidget *parent = 0);
 
-	void SetContent(QWidget *w);
+	void SetContent(QWidget *w, bool collapsed = true);
 	void AddHeaderWidget(QWidget *);
 
-public slots:
-	void Collapse(bool collapsed);
+protected:
+	bool eventFilter(QObject *obj, QEvent *event) override;
+
+private slots:
+	void AnimationFinished();
+	void Collapse(bool collapse);
+signals:
+	void Collapsed(bool);
 
 private:
+	void SetupAnimations();
+	void CleanUpPreviousContent();
+
 	QGridLayout *_mainLayout;
 	QHBoxLayout *_headerWidgetLayout;
 	QToolButton *_toggleButton;
 	QFrame *_headerLine;
 	QParallelAnimationGroup *_toggleAnimation = nullptr;
+	QParallelAnimationGroup *_contentAnimation = nullptr;
 	QScrollArea *_contentArea = nullptr;
+	QWidget *_content = nullptr;
 	int _animationDuration;
+	std::atomic_bool _transitioning = {false};
+	std::atomic_bool _collapsed = {false};
+	int _headerHeight = 0;
+	int _contentHeight = 0;
 };

src/headers/switch-audio.hpp

@@ -1,3 +1,10 @@
+/******************************************************************************
+    Note: Long-term goal is to remove this tab / file.
+    Most functionality shall be moved to the Macro tab instead.
+
+    So if you plan to make changes here, please consider applying them to the
+    corresponding macro tab functionality instead.
+******************************************************************************/
 #pragma once
 #include <QSpinBox>
 #include <limits>

src/headers/switch-executable.hpp

@@ -1,3 +1,10 @@
+/******************************************************************************
+    Note: Long-term goal is to remove this tab / file.
+    Most functionality shall be moved to the Macro tab instead.
+
+    So if you plan to make changes here, please consider applying them to the
+    corresponding macro tab functionality instead.
+******************************************************************************/
 #pragma once
 #include <QCheckBox>
 #include "switch-generic.hpp"

src/headers/switch-file.hpp

@@ -1,3 +1,10 @@
+/******************************************************************************
+    Note: Long-term goal is to remove this tab / file.
+    Most functionality shall be moved to the Macro tab instead.
+
+    So if you plan to make changes here, please consider applying them to the
+    corresponding macro tab functionality instead.
+******************************************************************************/
 #pragma once
 #include "switch-generic.hpp"
 #include <QPlainTextEdit>

src/headers/switch-idle.hpp

@@ -1,3 +1,10 @@
+/******************************************************************************
+    Note: Long-term goal is to remove this tab / file.
+    Most functionality shall be moved to the Macro tab instead.
+
+    So if you plan to make changes here, please consider applying them to the
+    corresponding macro tab functionality instead.
+******************************************************************************/
 #pragma once
 #include "switch-generic.hpp"
 

src/headers/switch-media.hpp

@@ -1,3 +1,10 @@
+/******************************************************************************
+    Note: Long-term goal is to remove this tab / file.
+    Most functionality shall be moved to the Macro tab instead.
+
+    So if you plan to make changes here, please consider applying them to the
+    corresponding macro tab functionality instead.
+******************************************************************************/
 #pragma once
 #include "switch-generic.hpp"
 

src/headers/switch-network.hpp

@@ -33,6 +33,10 @@ public:
 
 	std::string GetClientUri();
 
+	bool ShouldSendSceneChange();
+	bool ShouldSendFrontendSceneChange();
+	bool ShouldSendPrviewSceneChange();
+
 	// Server
 	bool ServerEnabled;
 	uint64_t ServerPort;
@@ -42,7 +46,9 @@ public:
 	bool ClientEnabled;
 	std::string Address;
 	uint64_t ClientPort;
-	bool SendAll;
+	bool SendSceneChange;
+	bool SendSceneChangeAll;
+	bool SendPreview;
 };
 
 class WSServer : public QObject {
@@ -53,7 +59,7 @@ public:
 	virtual ~WSServer();
 	void start(quint16 port, bool lockToIPv4);
 	void stop();
-	void sendMessage(sceneSwitchInfo sceneSwitch);
+	void sendMessage(sceneSwitchInfo sceneSwitch, bool preview = false);
 	QThreadPool *threadPool() { return &_threadPool; }
 
 private:

src/headers/switch-pause.hpp

@@ -1,3 +1,10 @@
+/******************************************************************************
+    Note: Long-term goal is to remove this tab / file.
+    Most functionality shall be moved to the Macro tab instead.
+
+    So if you plan to make changes here, please consider applying them to the
+    corresponding macro tab functionality instead.
+******************************************************************************/
 #pragma once
 #include "switch-generic.hpp"
 

src/headers/switch-random.hpp

@@ -1,3 +1,10 @@
+/******************************************************************************
+    Note: Long-term goal is to remove this tab / file.
+    Most functionality shall be moved to the Macro tab instead.
+
+    So if you plan to make changes here, please consider applying them to the
+    corresponding macro tab functionality instead.
+******************************************************************************/
 #pragma once
 #include "switch-generic.hpp"
 

src/headers/switch-screen-region.hpp

@@ -1,3 +1,10 @@
+/******************************************************************************
+    Note: Long-term goal is to remove this tab / file.
+    Most functionality shall be moved to the Macro tab instead.
+
+    So if you plan to make changes here, please consider applying them to the
+    corresponding macro tab functionality instead.
+******************************************************************************/
 #pragma once
 #include <QSpinBox>
 #include "switch-generic.hpp"

src/headers/switch-sequence.hpp

@@ -1,3 +1,10 @@
+/******************************************************************************
+    Note: Long-term goal is to remove this tab / file.
+    Most functionality shall be moved to the Macro tab instead.
+
+    So if you plan to make changes here, please consider applying them to the
+    corresponding macro tab functionality instead.
+******************************************************************************/
 #pragma once
 #include <QVBoxLayout>
 
@@ -28,11 +35,9 @@ struct SceneSequenceSwitch : SceneSwitcherEntry {
 	bool reduce();
 	SceneSequenceSwitch *extend();
 
-	bool checkMatch(OBSWeakSource currentScene, int &linger,
-			SceneSequenceSwitch *root = nullptr);
+	bool checkMatch(int &linger, SceneSequenceSwitch *root = nullptr);
 	bool checkDurationMatchInterruptible();
-	void prepareUninterruptibleMatch(OBSWeakSource currentScene,
-					 int &linger);
+	void prepareUninterruptibleMatch(int &linger);
 	void advanceActiveSequence();
 	void logAdvanceSequence();
 	void logSequenceCanceled();

src/headers/switch-time.hpp

@@ -1,3 +1,10 @@
+/******************************************************************************
+    Note: Long-term goal is to remove this tab / file.
+    Most functionality shall be moved to the Macro tab instead.
+
+    So if you plan to make changes here, please consider applying them to the
+    corresponding macro tab functionality instead.
+******************************************************************************/
 #pragma once
 #include <QTimeEdit>
 

src/headers/switch-video.hpp

@@ -1,3 +1,10 @@
+/******************************************************************************
+    Note: Long-term goal is to remove this tab / file.
+    Most functionality shall be moved to the Macro tab instead.
+
+    So if you plan to make changes here, please consider applying them to the
+    corresponding macro tab functionality instead.
+******************************************************************************/
 #pragma once
 #include <QSpinBox>
 

src/headers/switch-window.hpp

@@ -1,3 +1,10 @@
+/******************************************************************************
+    Note: Long-term goal is to remove this tab / file.
+    Most functionality shall be moved to the Macro tab instead.
+
+    So if you plan to make changes here, please consider applying them to the
+    corresponding macro tab functionality instead.
+******************************************************************************/
 #pragma once
 #include "switch-generic.hpp"
 

src/headers/switcher-data-structs.hpp

@@ -67,7 +67,6 @@ struct SwitcherData {
 	std::mutex m;
 	bool transitionActive = false;
 	bool waitForTransition = false;
-	std::condition_variable transitionCv;
 	bool stop = false;
 	bool verbose = false;
 	bool disableHints = false;
@@ -78,8 +77,8 @@ struct SwitcherData {
 	int interval = default_interval;
 
 	obs_source_t *waitScene = nullptr;
+	OBSWeakSource currentScene = nullptr;
 	OBSWeakSource previousScene = nullptr;
-	OBSWeakSource previousSceneHelper = nullptr;
 	OBSWeakSource lastRandomScene;
 	SceneGroup *lastRandomSceneGroup;
 	OBSWeakSource nonMatchingScene;
@@ -92,15 +91,19 @@ struct SwitcherData {
 	std::chrono::high_resolution_clock::time_point lastMatchTime;
 
 	std::deque<Macro> macros;
-	// Allow only one macro scene change per scene switcher interval
-	// with the top macro having the highest priority
+	std::condition_variable macroWaitCv;
+	std::atomic_bool abortMacroWait = {false};
 	bool macroSceneSwitched = false;
+	bool replayBufferSaved = false;
 
 	std::deque<WindowSwitch> windowSwitches;
 	std::vector<std::string> ignoreIdleWindows;
 	std::string lastTitle;
+	std::string currentTitle;
 
 	std::deque<ScreenRegionSwitch> screenRegionSwitches;
+	std::pair<int, int> lastCursorPos = {0, 0};
+	bool cursorPosChanged = false;
 
 	std::vector<std::string> ignoreWindowsSwitches;
 
@@ -178,9 +181,9 @@ struct SwitcherData {
 	std::vector<int> tabOrder = std::vector<int>(tab_count);
 
 	bool hotkeysRegistered = false;
-	obs_hotkey_id startHotkey = 0;
-	obs_hotkey_id stopHotkey = 0;
-	obs_hotkey_id toggleHotkey = 0;
+	obs_hotkey_id startHotkey = OBS_INVALID_HOTKEY_ID;
+	obs_hotkey_id stopHotkey = OBS_INVALID_HOTKEY_ID;
+	obs_hotkey_id toggleHotkey = OBS_INVALID_HOTKEY_ID;
 
 	bool saveWindowGeo = false;
 	QPoint windowPos = {};
@@ -192,6 +195,7 @@ struct SwitcherData {
 	void Start();
 	void Stop();
 
+	void setWaitScene();
 	bool sceneChangedDuringWait();
 
 	bool prioFuncsValid();
@@ -200,8 +204,9 @@ struct SwitcherData {
 	void resetTabOrder();
 
 	void writeSceneInfoToFile();
-	void writeToStatusFile(QString status);
+	void writeToStatusFile(const QString &msg);
 
+	void setPreconditions();
 	bool checkForMatch(OBSWeakSource &scene, OBSWeakSource &transition,
 			   int &linger, bool &setPreviousSceneAsMatch,
 			   bool &macroMatch);
@@ -253,7 +258,7 @@ struct SwitcherData {
 	void saveNetworkSwitches(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 saveVersion(obs_data_t *obj, const std::string &currentVersion);
 
 	void loadSettings(obs_data_t *obj);
 	void loadMacros(obs_data_t *obj);

src/headers/utility.hpp

@@ -1,118 +1,37 @@
 #pragma once
-
 #include <QString>
-#include <QTextStream>
 #include <QLayout>
-#include <QLabel>
-#include <QMessageBox>
-#include <unordered_map>
-
+#include <QComboBox>
+#include <QMetaObject>
+#include <QListWidget>
+#include <QPushButton>
+#include <QColor>
 #include <obs.hpp>
-#include <obs-module.h>
 #include <obs-frontend-api.h>
+#include <deque>
+#include <unordered_map>
+#include "scene-group.hpp"
 
-static inline bool WeakSourceValid(obs_weak_source_t *ws)
-{
-	obs_source_t *source = obs_weak_source_get_source(ws);
-	if (source) {
-		obs_source_release(source);
-	}
-	return !!source;
-}
+class SceneSelection;
 
-static inline std::string GetWeakSourceName(obs_weak_source_t *weak_source)
-{
-	std::string name;
-
-	obs_source_t *source = obs_weak_source_get_source(weak_source);
-	if (source) {
-		name = obs_source_get_name(source);
-		obs_source_release(source);
-	}
-
-	return name;
-}
-
-static inline OBSWeakSource GetWeakSourceByName(const char *name)
-{
-	OBSWeakSource weak;
-	obs_source_t *source = obs_get_source_by_name(name);
-	if (source) {
-		weak = obs_source_get_weak_source(source);
-		obs_weak_source_release(weak);
-		obs_source_release(source);
-	}
-
-	return weak;
-}
-
-static inline OBSWeakSource GetWeakSourceByQString(const QString &name)
-{
-	return GetWeakSourceByName(name.toUtf8().constData());
-}
-
-static inline OBSWeakSource GetWeakTransitionByName(const char *transitionName)
-{
-	OBSWeakSource weak;
-	obs_source_t *source = nullptr;
-
-	if (strcmp(transitionName, "Default") == 0) {
-		source = obs_frontend_get_current_transition();
-		weak = obs_source_get_weak_source(source);
-		obs_source_release(source);
-		obs_weak_source_release(weak);
-		return weak;
-	}
-
-	obs_frontend_source_list *transitions = new obs_frontend_source_list();
-	obs_frontend_get_transitions(transitions);
-	bool match = false;
-
-	for (size_t i = 0; i < transitions->sources.num; i++) {
-		const char *name =
-			obs_source_get_name(transitions->sources.array[i]);
-		if (strcmp(transitionName, name) == 0) {
-			match = true;
-			source = transitions->sources.array[i];
-			break;
-		}
-	}
-
-	if (match) {
-		weak = obs_source_get_weak_source(source);
-		obs_weak_source_release(weak);
-	}
-	obs_frontend_source_list_free(transitions);
-
-	return weak;
-}
-
-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;
-}
+bool WeakSourceValid(obs_weak_source_t *ws);
+std::string GetWeakSourceName(obs_weak_source_t *weak_source);
+OBSWeakSource GetWeakSourceByName(const char *name);
+OBSWeakSource GetWeakSourceByQString(const QString &name);
+OBSWeakSource GetWeakTransitionByName(const char *transitionName);
+OBSWeakSource GetWeakTransitionByQString(const QString &name);
+OBSWeakSource GetWeakFilterByName(OBSWeakSource source, const char *name);
+OBSWeakSource GetWeakFilterByQString(OBSWeakSource source, const QString &name);
+bool compareIgnoringLineEnding(QString &s1, QString &s2);
+std::string getSourceSettings(OBSWeakSource ws);
+void setSourceSettings(obs_source_t *s, const std::string &settings);
+bool compareSourceSettings(const OBSWeakSource &source,
+			   const std::string &settings, bool regex);
+std::vector<obs_scene_item *> getSceneItemsWithName(OBSScene scene,
+						    std::string &name);
+std::string getDataFilePath(const std::string &file);
+QString formatJsonString(std::string);
+QString formatJsonString(const char *);
 
 /**
  * Populate layout with labels and widgets based on provided text
@@ -122,95 +41,40 @@ getNextDelim(std::string text,
  * @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();
-	}
-}
-
-static inline void clearLayout(QLayout *layout)
-{
-	QLayoutItem *item;
-	while ((item = layout->takeAt(0))) {
-		if (item->layout()) {
-			clearLayout(item->layout());
-			delete item->layout();
-		}
-		if (item->widget()) {
-			delete item->widget();
-		}
-		delete item;
-	}
-}
-
-static inline bool compareIgnoringLineEnding(QString &s1, QString &s2)
-{
-	// Let QT deal with different types of lineendings
-	QTextStream s1stream(&s1);
-	QTextStream s2stream(&s2);
-
-	while (!s1stream.atEnd() || !s2stream.atEnd()) {
-		QString s1s = s1stream.readLine();
-		QString s2s = s2stream.readLine();
-		if (s1s != s2s) {
-			return false;
-		}
-	}
-
-	if (!s1stream.atEnd() && !s2stream.atEnd()) {
-		return false;
-	}
-
-	return true;
-}
-
-static inline bool DisplayMessage(QString msg, bool question = false)
-{
-	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 placeWidgets(std::string text, QBoxLayout *layout,
+		  std::unordered_map<std::string, QWidget *> placeholders,
+		  bool addStretch = true);
+void deleteLayoutItem(QLayoutItem *item);
+void clearLayout(QLayout *layout);
+QMetaObject::Connection PulseWidget(QWidget *widget, QColor endColor,
+				    QColor = QColor(0, 0, 0, 0),
+				    QString specifier = "QLabel ");
+void listAddClicked(QListWidget *list, QWidget *newWidget,
+		    QPushButton *addButton = nullptr,
+		    QMetaObject::Connection *addHighlight = nullptr);
+bool listMoveUp(QListWidget *list);
+bool listMoveDown(QListWidget *list);
+bool DisplayMessage(const QString &msg, bool question = false);
+void addSelectionEntry(QComboBox *sel, const char *description,
+		       bool selectable = false, const char *tooltip = "");
+void populateTransitionSelection(QComboBox *sel, bool addCurrent = true,
+				 bool addSelect = true,
+				 bool selectable = false);
+void populateWindowSelection(QComboBox *sel, bool addSelect = true);
+void populateAudioSelection(QComboBox *sel, bool addSelect = true);
+void populateVideoSelection(QComboBox *sel, bool addSelect = true);
+void populateMediaSelection(QComboBox *sel, bool addSelect = true);
+void populateProcessSelection(QComboBox *sel, bool addSelect = true);
+void populateSourceSelection(QComboBox *list, bool addSelect = true);
+void populateSceneSelection(QComboBox *sel, bool addPrevious = false,
+			    bool addCurrent = false, bool addAny = false,
+			    bool addSceneGroup = false,
+			    std::deque<SceneGroup> *sceneGroups = nullptr,
+			    bool addSelect = true, std::string selectText = "",
+			    bool selectable = false);
+void populateSourcesWithFilterSelection(QComboBox *list);
+void populateFilterSelection(QComboBox *list,
+			     OBSWeakSource weakSource = nullptr);
+void populateSceneItemSelection(QComboBox *list,
+				OBSWeakSource sceneWeakSource = nullptr);
+void populateSceneItemSelection(QComboBox *list, SceneSelection &s);

src/hotkey.cpp

@@ -1,7 +1,8 @@
+#include "headers/hotkey.hpp"
+#include "headers/advanced-scene-switcher.hpp"
 #include <obs-module.h>
 #include <fstream>
 #include <regex>
-#include "headers/advanced-scene-switcher.hpp"
 
 void startHotkeyFunc(void *data, obs_hotkey_id id, obs_hotkey_t *hotkey,
 		     bool pressed)

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

@@ -1,7 +1,11 @@
+#include "../headers/hotkey.hpp"
+
 #include <X11/Xlib.h>
 #include <X11/Xatom.h>
 #include <X11/Xutil.h>
+#include <X11/keysym.h>
 #include <X11/extensions/scrnsaver.h>
+#include <X11/extensions/XTest.h>
 #undef Bool
 #undef CursorShape
 #undef Expose
@@ -15,11 +19,19 @@
 #undef Unsorted
 #include <util/platform.h>
 #include <vector>
+#include <thread>
+#include <unordered_map>
 #include <QStringList>
 #include <QRegularExpression>
+#include <QLibrary>
 
 static Display *xdisplay = 0;
 
+static QLibrary *libXtstHandle = nullptr;
+typedef int (*keyPressFunc)(Display *, unsigned int, bool, unsigned long);
+static keyPressFunc pressFunc = nullptr;
+bool canSimulateKeyPresses = false;
+
 Display *disp()
 {
 	if (!xdisplay)
@@ -211,7 +223,7 @@ void GetCurrentWindowTitle(std::string &title)
 
 	int status = 0;
 	XTextProperty text;
-	if (xstatus == Success) {
+	if (xstatus == Success && data[0]) {
 		status = XGetTextProperty(disp(), data[0], &text,
 					  XInternAtom(disp(), "_NET_WM_NAME",
 						      true));
@@ -242,18 +254,17 @@ std::pair<int, int> getCursorPos()
 	int win_y;
 	unsigned int mask;
 
-	dpy = XOpenDisplay(NULL);
+	dpy = disp();
 	root = XDefaultRootWindow(dpy);
 
 	if (XQueryPointer(dpy, root, &ret_root, &ret_child, &root_x, &root_y,
 			  &win_x, &win_y, &mask)) {
 		pos = std::pair<int, int>(root_x, root_y);
 	}
-	XCloseDisplay(dpy);
 	return pos;
 }
 
-bool isMaximized(std::string &title)
+bool isMaximized(const std::string &title)
 {
 	if (!ewmhIsSupported())
 		return false;
@@ -302,7 +313,7 @@ bool isMaximized(std::string &title)
 	return false;
 }
 
-bool isFullscreen(std::string &title)
+bool isFullscreen(const std::string &title)
 {
 	if (!ewmhIsSupported())
 		return false;
@@ -382,14 +393,186 @@ int secondsSinceLastInput()
 
 	mit_info = XScreenSaverAllocInfo();
 
-	if ((display = XOpenDisplay(NULL)) == NULL) {
-		return (-1);
+	if ((display = disp()) == NULL) {
+		return -1;
 	}
 	screen = DefaultScreen(display);
 	XScreenSaverQueryInfo(display, RootWindow(display, screen), mit_info);
 	idle_time = (mit_info->idle) / 1000;
 	XFree(mit_info);
-	XCloseDisplay(display);
 
 	return idle_time;
 }
+
+static std::unordered_map<HotkeyType, long> keyTable = {
+	// Chars
+	{HotkeyType::Key_A, XK_A},
+	{HotkeyType::Key_B, XK_B},
+	{HotkeyType::Key_C, XK_C},
+	{HotkeyType::Key_D, XK_D},
+	{HotkeyType::Key_E, XK_E},
+	{HotkeyType::Key_F, XK_F},
+	{HotkeyType::Key_G, XK_G},
+	{HotkeyType::Key_H, XK_H},
+	{HotkeyType::Key_I, XK_I},
+	{HotkeyType::Key_J, XK_J},
+	{HotkeyType::Key_K, XK_K},
+	{HotkeyType::Key_L, XK_L},
+	{HotkeyType::Key_M, XK_M},
+	{HotkeyType::Key_N, XK_N},
+	{HotkeyType::Key_O, XK_O},
+	{HotkeyType::Key_P, XK_P},
+	{HotkeyType::Key_Q, XK_Q},
+	{HotkeyType::Key_R, XK_R},
+	{HotkeyType::Key_S, XK_S},
+	{HotkeyType::Key_T, XK_T},
+	{HotkeyType::Key_U, XK_U},
+	{HotkeyType::Key_V, XK_V},
+	{HotkeyType::Key_W, XK_W},
+	{HotkeyType::Key_X, XK_X},
+	{HotkeyType::Key_Y, XK_Y},
+	{HotkeyType::Key_Z, XK_Z},
+
+	// Numbers
+	{HotkeyType::Key_0, XK_0},
+	{HotkeyType::Key_1, XK_1},
+	{HotkeyType::Key_2, XK_2},
+	{HotkeyType::Key_3, XK_3},
+	{HotkeyType::Key_4, XK_4},
+	{HotkeyType::Key_5, XK_5},
+	{HotkeyType::Key_6, XK_6},
+	{HotkeyType::Key_7, XK_7},
+	{HotkeyType::Key_8, XK_8},
+	{HotkeyType::Key_9, XK_9},
+
+	{HotkeyType::Key_F1, XK_F1},
+	{HotkeyType::Key_F2, XK_F2},
+	{HotkeyType::Key_F3, XK_F3},
+	{HotkeyType::Key_F4, XK_F4},
+	{HotkeyType::Key_F5, XK_F5},
+	{HotkeyType::Key_F6, XK_F6},
+	{HotkeyType::Key_F7, XK_F7},
+	{HotkeyType::Key_F8, XK_F8},
+	{HotkeyType::Key_F9, XK_F9},
+	{HotkeyType::Key_F10, XK_F10},
+	{HotkeyType::Key_F11, XK_F11},
+	{HotkeyType::Key_F12, XK_F12},
+	{HotkeyType::Key_F13, XK_F13},
+	{HotkeyType::Key_F14, XK_F14},
+	{HotkeyType::Key_F15, XK_F15},
+	{HotkeyType::Key_F16, XK_F16},
+	{HotkeyType::Key_F17, XK_F17},
+	{HotkeyType::Key_F18, XK_F18},
+	{HotkeyType::Key_F19, XK_F19},
+	{HotkeyType::Key_F20, XK_F20},
+	{HotkeyType::Key_F21, XK_F21},
+	{HotkeyType::Key_F22, XK_F22},
+	{HotkeyType::Key_F23, XK_F23},
+	{HotkeyType::Key_F24, XK_F24},
+
+	{HotkeyType::Key_Escape, XK_Escape},
+	{HotkeyType::Key_Space, XK_space},
+	{HotkeyType::Key_Return, XK_Return},
+	{HotkeyType::Key_Backspace, XK_BackSpace},
+	{HotkeyType::Key_Tab, XK_Tab},
+
+	{HotkeyType::Key_Shift_L, XK_Shift_L},
+	{HotkeyType::Key_Shift_R, XK_Shift_R},
+	{HotkeyType::Key_Control_L, XK_Control_L},
+	{HotkeyType::Key_Control_R, XK_Control_R},
+	{HotkeyType::Key_Alt_L, XK_Alt_L},
+	{HotkeyType::Key_Alt_R, XK_Alt_R},
+	{HotkeyType::Key_Win_L, XK_Super_L},
+	{HotkeyType::Key_Win_R, XK_Super_R},
+	{HotkeyType::Key_Apps, XK_Hyper_L},
+
+	{HotkeyType::Key_CapsLock, XK_Caps_Lock},
+	{HotkeyType::Key_NumLock, XK_Num_Lock},
+	{HotkeyType::Key_ScrollLock, XK_Scroll_Lock},
+
+	{HotkeyType::Key_PrintScreen, XK_Print},
+	{HotkeyType::Key_Pause, XK_Pause},
+
+	{HotkeyType::Key_Insert, XK_Insert},
+	{HotkeyType::Key_Delete, XK_Delete},
+	{HotkeyType::Key_PageUP, XK_Page_Up},
+	{HotkeyType::Key_PageDown, XK_Page_Down},
+	{HotkeyType::Key_Home, XK_Home},
+	{HotkeyType::Key_End, XK_End},
+
+	{HotkeyType::Key_Left, XK_Left},
+	{HotkeyType::Key_Up, XK_Up},
+	{HotkeyType::Key_Right, XK_Right},
+	{HotkeyType::Key_Down, XK_Down},
+
+	{HotkeyType::Key_Numpad0, XK_KP_0},
+	{HotkeyType::Key_Numpad1, XK_KP_1},
+	{HotkeyType::Key_Numpad2, XK_KP_2},
+	{HotkeyType::Key_Numpad3, XK_KP_3},
+	{HotkeyType::Key_Numpad4, XK_KP_4},
+	{HotkeyType::Key_Numpad5, XK_KP_5},
+	{HotkeyType::Key_Numpad6, XK_KP_6},
+	{HotkeyType::Key_Numpad7, XK_KP_7},
+	{HotkeyType::Key_Numpad8, XK_KP_8},
+	{HotkeyType::Key_Numpad9, XK_KP_9},
+
+	{HotkeyType::Key_NumpadAdd, XK_KP_Add},
+	{HotkeyType::Key_NumpadSubtract, XK_KP_Subtract},
+	{HotkeyType::Key_NumpadMultiply, XK_KP_Multiply},
+	{HotkeyType::Key_NumpadDivide, XK_KP_Divide},
+	{HotkeyType::Key_NumpadDecimal, XK_KP_Decimal},
+	{HotkeyType::Key_NumpadEnter, XK_KP_Enter},
+};
+
+void PressKeys(const std::vector<HotkeyType> keys)
+{
+	if (!canSimulateKeyPresses) {
+		return;
+	}
+
+	Display *display = disp();
+	if (display == NULL)
+		return;
+
+	// Press keys
+	for (auto &key : keys) {
+		auto it = keyTable.find(key);
+		if (it == keyTable.end()) {
+			continue;
+		}
+		pressFunc(display, XKeysymToKeycode(display, it->second), true,
+			  CurrentTime);
+	}
+	XFlush(display);
+
+	std::this_thread::sleep_for(std::chrono::milliseconds(300));
+
+	// Release keys
+	for (auto &key : keys) {
+		auto it = keyTable.find(key);
+		if (it == keyTable.end()) {
+			continue;
+		}
+		pressFunc(display, XKeysymToKeycode(display, it->second), false,
+			  CurrentTime);
+	}
+
+	XFlush(display);
+}
+
+void PlatformInit()
+{
+	libXtstHandle = new QLibrary("libXtst.so", nullptr);
+	pressFunc = (keyPressFunc)libXtstHandle->resolve("XTestFakeKeyEvent");
+	int _;
+	canSimulateKeyPresses = pressFunc &&
+				!XQueryExtension(disp(), "XTEST", &_, &_, &_);
+}
+
+void PlatformCleanup()
+{
+	delete libXtstHandle;
+	libXtstHandle = nullptr;
+
+	cleanupDisplay();
+}

src/macro-action-audio.cpp

@@ -2,7 +2,7 @@
 #include "headers/advanced-scene-switcher.hpp"
 #include "headers/utility.hpp"
 
-const int MacroActionAudio::id = 2;
+const std::string MacroActionAudio::id = "audio";
 
 bool MacroActionAudio::_registered = MacroActionFactory::Register(
 	MacroActionAudio::id,
@@ -75,6 +75,14 @@ bool MacroActionAudio::Load(obs_data_t *obj)
 	return true;
 }
 
+std::string MacroActionAudio::GetShortDesc()
+{
+	if (_audioSource) {
+		return GetWeakSourceName(_audioSource);
+	}
+	return "";
+}
+
 static inline void populateActionSelection(QComboBox *list)
 {
 	for (auto entry : actionTypes) {
@@ -94,7 +102,7 @@ MacroActionAudioEdit::MacroActionAudioEdit(
 	_volumePercent->setSuffix("%");
 
 	populateActionSelection(_actions);
-	AdvSceneSwitcher::populateAudioSelection(_audioSources);
+	populateAudioSelection(_audioSources);
 
 	QWidget::connect(_actions, SIGNAL(currentIndexChanged(int)), this,
 			 SLOT(ActionChanged(int)));
@@ -130,17 +138,8 @@ bool hasSourceControl(AudioAction action)
 	return action != AudioAction::MASTER_VOLUME;
 }
 
-void MacroActionAudioEdit::UpdateEntryData()
+void MacroActionAudioEdit::SetWidgetVisibility()
 {
-	if (!_entryData) {
-		return;
-	}
-
-	_audioSources->setCurrentText(
-		GetWeakSourceName(_entryData->_audioSource).c_str());
-	_actions->setCurrentIndex(static_cast<int>(_entryData->_action));
-	_volumePercent->setValue(_entryData->_volume);
-
 	if (hasVolumeControl(_entryData->_action)) {
 		_volumePercent->show();
 	} else {
@@ -154,6 +153,20 @@ void MacroActionAudioEdit::UpdateEntryData()
 	}
 }
 
+void MacroActionAudioEdit::UpdateEntryData()
+{
+	if (!_entryData) {
+		return;
+	}
+
+	_audioSources->setCurrentText(
+		GetWeakSourceName(_entryData->_audioSource).c_str());
+	_actions->setCurrentIndex(static_cast<int>(_entryData->_action));
+	_volumePercent->setValue(_entryData->_volume);
+
+	SetWidgetVisibility();
+}
+
 void MacroActionAudioEdit::SourceChanged(const QString &text)
 {
 	if (_loading || !_entryData) {
@@ -162,6 +175,8 @@ void MacroActionAudioEdit::SourceChanged(const QString &text)
 
 	std::lock_guard<std::mutex> lock(switcher->m);
 	_entryData->_audioSource = GetWeakSourceByQString(text);
+	emit HeaderInfoChanged(
+		QString::fromStdString(_entryData->GetShortDesc()));
 }
 
 void MacroActionAudioEdit::ActionChanged(int value)
@@ -172,7 +187,7 @@ void MacroActionAudioEdit::ActionChanged(int value)
 
 	std::lock_guard<std::mutex> lock(switcher->m);
 	_entryData->_action = static_cast<AudioAction>(value);
-	UpdateEntryData();
+	SetWidgetVisibility();
 }
 
 void MacroActionAudioEdit::VolumeChanged(int value)

src/macro-action-edit.cpp

@@ -1,11 +1,13 @@
-#include "headers/macro-action-edit.hpp"
-#include "headers/macro-action-switch-scene.hpp"
-#include "headers/utility.hpp"
 #include "headers/advanced-scene-switcher.hpp"
+#include "headers/macro-action-edit.hpp"
+#include "headers/macro-action-scene-switch.hpp"
+#include "headers/section.hpp"
+#include "headers/macro-controls.hpp"
+#include "headers/utility.hpp"
 
-std::map<int, MacroActionInfo> MacroActionFactory::_methods;
+std::map<std::string, MacroActionInfo> MacroActionFactory::_methods;
 
-bool MacroActionFactory::Register(int id, MacroActionInfo info)
+bool MacroActionFactory::Register(const std::string &id, MacroActionInfo info)
 {
 	if (auto it = _methods.find(id); it == _methods.end()) {
 		_methods[id] = info;
@@ -14,7 +16,7 @@ bool MacroActionFactory::Register(int id, MacroActionInfo info)
 	return false;
 }
 
-std::shared_ptr<MacroAction> MacroActionFactory::Create(const int id)
+std::shared_ptr<MacroAction> MacroActionFactory::Create(const std::string &id)
 {
 	if (auto it = _methods.find(id); it != _methods.end())
 		return it->second._createFunc();
@@ -22,7 +24,8 @@ std::shared_ptr<MacroAction> MacroActionFactory::Create(const int id)
 	return nullptr;
 }
 
-QWidget *MacroActionFactory::CreateWidget(const int id, QWidget *parent,
+QWidget *MacroActionFactory::CreateWidget(const std::string &id,
+					  QWidget *parent,
 					  std::shared_ptr<MacroAction> action)
 {
 	if (auto it = _methods.find(id); it != _methods.end())
@@ -31,6 +34,24 @@ QWidget *MacroActionFactory::CreateWidget(const int id, QWidget *parent,
 	return nullptr;
 }
 
+std::string MacroActionFactory::GetActionName(const std::string &id)
+{
+	if (auto it = _methods.find(id); it != _methods.end()) {
+		return it->second._name;
+	}
+	return "unknown action";
+}
+
+std::string MacroActionFactory::GetIdByName(const QString &name)
+{
+	for (auto it : _methods) {
+		if (name == obs_module_text(it.second._name.c_str())) {
+			return it.first;
+		}
+	}
+	return "";
+}
+
 static inline void populateActionSelection(QComboBox *list)
 {
 	for (auto entry : MacroActionFactory::GetActionTypes()) {
@@ -40,56 +61,93 @@ static inline void populateActionSelection(QComboBox *list)
 
 MacroActionEdit::MacroActionEdit(QWidget *parent,
 				 std::shared_ptr<MacroAction> *entryData,
-				 int type, bool startCollapsed)
-	: QWidget(parent)
+				 const std::string &id)
+	: MacroSegmentEdit(parent), _entryData(entryData)
 {
 	_actionSelection = new QComboBox();
-	_section = new Section(300);
 
-	QWidget::connect(_actionSelection, SIGNAL(currentIndexChanged(int)),
-			 this, SLOT(ActionSelectionChanged(int)));
+	QWidget::connect(_actionSelection,
+			 SIGNAL(currentTextChanged(const QString &)), this,
+			 SLOT(ActionSelectionChanged(const QString &)));
 
 	populateActionSelection(_actionSelection);
 
 	_section->AddHeaderWidget(_actionSelection);
+	_section->AddHeaderWidget(_headerInfo);
 
 	QVBoxLayout *mainLayout = new QVBoxLayout;
 	mainLayout->addWidget(_section);
+	mainLayout->addWidget(_controls);
 	setLayout(mainLayout);
 
 	_entryData = entryData;
-	UpdateEntryData(type);
+	UpdateEntryData(id);
 
 	_loading = false;
-	_section->Collapse(startCollapsed);
 }
 
-void MacroActionEdit::ActionSelectionChanged(int idx)
+void MacroActionEdit::ActionSelectionChanged(const QString &text)
 {
 	if (_loading || !_entryData) {
 		return;
 	}
 
+	std::string id = MacroActionFactory::GetIdByName(text);
+	HeaderInfoChanged("");
+
 	std::lock_guard<std::mutex> lock(switcher->m);
 	_entryData->reset();
-	*_entryData = MacroActionFactory::Create(idx);
-	auto widget =
-		MacroActionFactory::CreateWidget(idx, window(), *_entryData);
-	_section->SetContent(widget);
-	_section->Collapse(false);
+	*_entryData = MacroActionFactory::Create(id);
+	auto widget = MacroActionFactory::CreateWidget(id, this, *_entryData);
+	QWidget::connect(widget, SIGNAL(HeaderInfoChanged(const QString &)),
+			 this, SLOT(HeaderInfoChanged(const QString &)));
+	_section->SetContent(widget, false);
+	SetFocusPolicyOfWidgets();
 }
 
-void MacroActionEdit::UpdateEntryData(int type)
+void MacroActionEdit::UpdateEntryData(const std::string &id)
 {
-	_actionSelection->setCurrentIndex(type);
-	auto widget =
-		MacroActionFactory::CreateWidget(type, window(), *_entryData);
-	_section->SetContent(widget);
+	_actionSelection->setCurrentText(
+		obs_module_text(MacroActionFactory::GetActionName(id).c_str()));
+	auto widget = MacroActionFactory::CreateWidget(id, this, *_entryData);
+	QWidget::connect(widget, SIGNAL(HeaderInfoChanged(const QString &)),
+			 this, SLOT(HeaderInfoChanged(const QString &)));
+	HeaderInfoChanged(
+		QString::fromStdString((*_entryData)->GetShortDesc()));
+	_section->SetContent(widget, (*_entryData)->GetCollapsed());
+	SetFocusPolicyOfWidgets();
 }
 
-void MacroActionEdit::Collapse(bool collapsed)
+MacroSegment *MacroActionEdit::Data()
 {
-	_section->Collapse(collapsed);
+	return _entryData->get();
+}
+
+void AdvSceneSwitcher::AddMacroAction(int idx)
+{
+	auto macro = getSelectedMacro();
+	if (!macro) {
+		return;
+	}
+
+	if (idx < 0 || idx > (int)macro->Actions().size()) {
+		return;
+	}
+
+	MacroActionSwitchScene temp;
+	std::string id = temp.GetId();
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	auto action = macro->Actions().emplace(macro->Actions().begin() + idx,
+					       MacroActionFactory::Create(id));
+	macro->UpdateActionIndices();
+
+	// All entry pointers in existing edit widgets after the new entry will
+	// be invalidated by adding the new entry so we have to recreate them
+	// and because I am lazy I am recreating every widget.
+	//
+	// If performance should become a concern this has to be revisited.
+	SetEditMacro(*macro);
 }
 
 void AdvSceneSwitcher::on_actionAdd_clicked()
@@ -98,12 +156,34 @@ void AdvSceneSwitcher::on_actionAdd_clicked()
 	if (!macro) {
 		return;
 	}
-	std::lock_guard<std::mutex> lock(switcher->m);
-	macro->Actions().emplace_back(MacroActionFactory::Create(0));
-	auto newEntry = new MacroActionEdit(this, &macro->Actions().back(), 0);
-	ui->macroEditActionLayout->addWidget(newEntry);
+
+	AddMacroAction((int)macro->Actions().size());
 	ui->macroEditActionHelp->setVisible(false);
-	newEntry->Collapse(false);
+}
+
+void AdvSceneSwitcher::RemoveMacroAction(int idx)
+{
+	auto macro = getSelectedMacro();
+	if (!macro) {
+		return;
+	}
+
+	if (idx < 0 || idx >= (int)macro->Actions().size()) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	macro->Actions().erase(macro->Actions().begin() + idx);
+	switcher->abortMacroWait = true;
+	switcher->macroWaitCv.notify_one();
+	macro->UpdateActionIndices();
+
+	// All entry pointers in existing edit widgets after the new entry will
+	// be invalidated by adding the new entry so we have to recreate them
+	// and because I am lazy I am recreating every widget.
+	//
+	// If performance should become a concern this has to be revisited.
+	SetEditMacro(*macro);
 }
 
 void AdvSceneSwitcher::on_actionRemove_clicked()
@@ -112,24 +192,61 @@ void AdvSceneSwitcher::on_actionRemove_clicked()
 	if (!macro) {
 		return;
 	}
-	std::lock_guard<std::mutex> lock(switcher->m);
-	if (macro->Actions().empty()) {
+	RemoveMacroAction((int)macro->Actions().size() - 1);
+}
+
+void AdvSceneSwitcher::SwapActions(Macro *m, int pos1, int pos2)
+{
+	if (pos1 == pos2) {
 		return;
 	}
-	macro->Actions().pop_back();
-
-	int count = ui->macroEditActionLayout->count();
-	auto item = ui->macroEditActionLayout->takeAt(count - 1);
-
-	if (item) {
-		auto widget = item->widget();
-		if (widget) {
-			widget->setVisible(false);
-		}
-		delete item;
+	if (pos1 > pos2) {
+		std::swap(pos1, pos2);
 	}
 
-	if (count == 1) {
-		ui->macroEditActionHelp->setVisible(true);
-	}
+	std::lock_guard<std::mutex> lock(switcher->m);
+	iter_swap(m->Actions().begin() + pos1, m->Actions().begin() + pos2);
+	m->UpdateActionIndices();
+
+	auto a1 = m->Actions().begin() + pos1;
+	auto a2 = m->Actions().begin() + pos2;
+
+	auto item1 = ui->macroEditActionLayout->takeAt(pos1);
+	auto item2 = ui->macroEditActionLayout->takeAt(pos2 - 1);
+	deleteLayoutItem(item1);
+	deleteLayoutItem(item2);
+	auto widget1 = new MacroActionEdit(this, &(*a1), (*a1)->GetId());
+	auto widget2 = new MacroActionEdit(this, &(*a2), (*a2)->GetId());
+	ConnectControlSignals(widget1);
+	ConnectControlSignals(widget2);
+	ui->macroEditActionLayout->insertWidget(pos1, widget1);
+	ui->macroEditActionLayout->insertWidget(pos2, widget2);
+}
+
+void AdvSceneSwitcher::MoveMacroActionUp(int idx)
+{
+	auto macro = getSelectedMacro();
+	if (!macro) {
+		return;
+	}
+
+	if (idx < 1 || idx >= (int)macro->Actions().size()) {
+		return;
+	}
+
+	SwapActions(macro, idx, idx - 1);
+}
+
+void AdvSceneSwitcher::MoveMacroActionDown(int idx)
+{
+	auto macro = getSelectedMacro();
+	if (!macro) {
+		return;
+	}
+
+	if (idx < 0 || idx >= (int)macro->Actions().size() - 1) {
+		return;
+	}
+
+	SwapActions(macro, idx, idx + 1);
 }

src/macro-action-file.cpp

@@ -0,0 +1,187 @@
+#include "headers/macro-action-file.hpp"
+#include "headers/advanced-scene-switcher.hpp"
+#include "headers/utility.hpp"
+
+#include <QFile>
+#include <QTextStream>
+#include <QFileDialog>
+
+const std::string MacroActionFile::id = "file";
+
+bool MacroActionFile::_registered = MacroActionFactory::Register(
+	MacroActionFile::id,
+	{MacroActionFile::Create, MacroActionFileEdit::Create,
+	 "AdvSceneSwitcher.action.file"});
+
+const static std::map<FileAction, std::string> actionTypes = {
+	{FileAction::WRITE, "AdvSceneSwitcher.action.file.type.write"},
+	{FileAction::APPEND, "AdvSceneSwitcher.action.file.type.append"},
+};
+
+bool MacroActionFile::PerformAction()
+{
+	QString path = QString::fromStdString(_file);
+	QFile file(path);
+	bool open = false;
+	switch (_action) {
+	case FileAction::WRITE:
+		open = file.open(QIODevice::WriteOnly);
+		break;
+	case FileAction::APPEND:
+		open = file.open(QIODevice::WriteOnly | QIODevice::Append);
+		break;
+	default:
+		break;
+	}
+	if (open) {
+		QTextStream out(&file);
+		out << QString::fromStdString(_text);
+	}
+	return true;
+}
+
+void MacroActionFile::LogAction()
+{
+	auto it = actionTypes.find(_action);
+	if (it != actionTypes.end()) {
+		vblog(LOG_INFO, "performed action \"%s\" for file \"%s\"",
+		      it->second.c_str(), _file.c_str());
+	} else {
+		blog(LOG_WARNING, "ignored unknown file action %d",
+		     static_cast<int>(_action));
+	}
+}
+
+bool MacroActionFile::Save(obs_data_t *obj)
+{
+	MacroAction::Save(obj);
+	obs_data_set_string(obj, "file", _file.c_str());
+	obs_data_set_string(obj, "text", _text.c_str());
+	obs_data_set_int(obj, "action", static_cast<int>(_action));
+	return true;
+}
+
+bool MacroActionFile::Load(obs_data_t *obj)
+{
+	MacroAction::Load(obj);
+	_file = obs_data_get_string(obj, "file");
+	_text = obs_data_get_string(obj, "text");
+	_action = static_cast<FileAction>(obs_data_get_int(obj, "action"));
+	return true;
+}
+
+std::string MacroActionFile::GetShortDesc()
+{
+	return _file;
+}
+
+static inline void populateActionSelection(QComboBox *list)
+{
+	for (auto entry : actionTypes) {
+		list->addItem(obs_module_text(entry.second.c_str()));
+	}
+}
+
+MacroActionFileEdit::MacroActionFileEdit(
+	QWidget *parent, std::shared_ptr<MacroActionFile> entryData)
+	: QWidget(parent)
+{
+	_filePath = new QLineEdit();
+	_browseButton =
+		new QPushButton(obs_module_text("AdvSceneSwitcher.browse"));
+	_text = new QPlainTextEdit();
+	_actions = new QComboBox();
+
+	populateActionSelection(_actions);
+
+	QWidget::connect(_actions, SIGNAL(currentIndexChanged(int)), this,
+			 SLOT(ActionChanged(int)));
+	QWidget::connect(_filePath, SIGNAL(editingFinished()), this,
+			 SLOT(FilePathChanged()));
+	QWidget::connect(_browseButton, SIGNAL(clicked()), this,
+			 SLOT(BrowseButtonClicked()));
+	QWidget::connect(_text, SIGNAL(textChanged()), this,
+			 SLOT(TextChanged()));
+	;
+
+	QHBoxLayout *entryLayout = new QHBoxLayout;
+	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
+		{"{{filePath}}", _filePath},
+		{"{{browseButton}}", _browseButton},
+		{"{{matchText}}", _text},
+		{"{{actions}}", _actions},
+	};
+	placeWidgets(obs_module_text("AdvSceneSwitcher.action.file.entry"),
+		     entryLayout, widgetPlaceholders);
+
+	QVBoxLayout *mainLayout = new QVBoxLayout;
+	mainLayout->addLayout(entryLayout);
+	mainLayout->addWidget(_text);
+	setLayout(mainLayout);
+
+	_entryData = entryData;
+	UpdateEntryData();
+	_loading = false;
+}
+
+void MacroActionFileEdit::UpdateEntryData()
+{
+	if (!_entryData) {
+		return;
+	}
+
+	_actions->setCurrentIndex(static_cast<int>(_entryData->_action));
+	_filePath->setText(QString::fromStdString(_entryData->_file));
+	_text->setPlainText(QString::fromStdString(_entryData->_text));
+}
+
+void MacroActionFileEdit::FilePathChanged()
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_file = _filePath->text().toUtf8().constData();
+	emit HeaderInfoChanged(
+		QString::fromStdString(_entryData->GetShortDesc()));
+}
+
+void MacroActionFileEdit::BrowseButtonClicked()
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	QString path = QFileDialog::getSaveFileName(
+		this,
+		tr(obs_module_text("AdvSceneSwitcher.fileTab.selectWrite")),
+		QDir::currentPath(),
+		tr(obs_module_text("AdvSceneSwitcher.fileTab.anyFileType")));
+	if (path.isEmpty()) {
+		return;
+	}
+
+	_filePath->setText(path);
+	FilePathChanged();
+}
+
+void MacroActionFileEdit::TextChanged()
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_text = _text->toPlainText().toStdString();
+}
+
+void MacroActionFileEdit::ActionChanged(int value)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_action = static_cast<FileAction>(value);
+}

src/macro-action-filter.cpp

@@ -0,0 +1,219 @@
+#include "headers/macro-action-filter.hpp"
+#include "headers/advanced-scene-switcher.hpp"
+#include "headers/utility.hpp"
+
+const std::string MacroActionFilter::id = "filter";
+
+bool MacroActionFilter::_registered = MacroActionFactory::Register(
+	MacroActionFilter::id,
+	{MacroActionFilter::Create, MacroActionFilterEdit::Create,
+	 "AdvSceneSwitcher.action.filter"});
+
+const static std::map<FilterAction, std::string> actionTypes = {
+	{FilterAction::ENABLE, "AdvSceneSwitcher.action.filter.type.enable"},
+	{FilterAction::DISABLE, "AdvSceneSwitcher.action.filter.type.disable"},
+	{FilterAction::SETTINGS,
+	 "AdvSceneSwitcher.action.filter.type.settings"},
+};
+
+bool MacroActionFilter::PerformAction()
+{
+	auto s = obs_weak_source_get_source(_filter);
+	switch (_action) {
+	case FilterAction::ENABLE:
+		obs_source_set_enabled(s, true);
+		break;
+	case FilterAction::DISABLE:
+		obs_source_set_enabled(s, false);
+		break;
+	case FilterAction::SETTINGS:
+		setSourceSettings(s, _settings);
+		break;
+	default:
+		break;
+	}
+	obs_source_release(s);
+	return true;
+}
+
+void MacroActionFilter::LogAction()
+{
+	auto it = actionTypes.find(_action);
+	if (it != actionTypes.end()) {
+		vblog(LOG_INFO,
+		      "performed action \"%s\" for filter \"%s\" on source \"%s\"",
+		      it->second.c_str(), GetWeakSourceName(_filter).c_str(),
+		      GetWeakSourceName(_source).c_str());
+	} else {
+		blog(LOG_WARNING, "ignored unknown filter action %d",
+		     static_cast<int>(_action));
+	}
+}
+
+bool MacroActionFilter::Save(obs_data_t *obj)
+{
+	MacroAction::Save(obj);
+	obs_data_set_string(obj, "source", GetWeakSourceName(_source).c_str());
+	obs_data_set_string(obj, "filter", GetWeakSourceName(_filter).c_str());
+	obs_data_set_int(obj, "action", static_cast<int>(_action));
+	obs_data_set_string(obj, "settings", _settings.c_str());
+	return true;
+}
+
+bool MacroActionFilter::Load(obs_data_t *obj)
+{
+	MacroAction::Load(obj);
+	const char *sourceName = obs_data_get_string(obj, "source");
+	_source = GetWeakSourceByName(sourceName);
+	const char *filterName = obs_data_get_string(obj, "filter");
+	_filter = GetWeakFilterByQString(_source, filterName);
+	_action = static_cast<FilterAction>(obs_data_get_int(obj, "action"));
+	_settings = obs_data_get_string(obj, "settings");
+	return true;
+}
+
+std::string MacroActionFilter::GetShortDesc()
+{
+	if (_filter && _source) {
+		return GetWeakSourceName(_source) + " - " +
+		       GetWeakSourceName(_filter);
+	}
+	return "";
+}
+
+static inline void populateActionSelection(QComboBox *list)
+{
+	for (auto entry : actionTypes) {
+		list->addItem(obs_module_text(entry.second.c_str()));
+	}
+}
+
+MacroActionFilterEdit::MacroActionFilterEdit(
+	QWidget *parent, std::shared_ptr<MacroActionFilter> entryData)
+	: QWidget(parent)
+{
+	_sources = new QComboBox();
+	_filters = new QComboBox();
+	_actions = new QComboBox();
+	_getSettings = new QPushButton(
+		obs_module_text("AdvSceneSwitcher.action.filter.getSettings"));
+	_settings = new QPlainTextEdit();
+
+	populateActionSelection(_actions);
+	populateSourcesWithFilterSelection(_sources);
+
+	QWidget::connect(_actions, SIGNAL(currentIndexChanged(int)), this,
+			 SLOT(ActionChanged(int)));
+	QWidget::connect(_sources, SIGNAL(currentTextChanged(const QString &)),
+			 this, SLOT(SourceChanged(const QString &)));
+	QWidget::connect(_filters, SIGNAL(currentTextChanged(const QString &)),
+			 this, SLOT(FilterChanged(const QString &)));
+	QWidget::connect(_getSettings, SIGNAL(clicked()), this,
+			 SLOT(GetSettingsClicked()));
+	QWidget::connect(_settings, SIGNAL(textChanged()), this,
+			 SLOT(SettingsChanged()));
+
+	QHBoxLayout *entryLayout = new QHBoxLayout;
+
+	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
+		{"{{sources}}", _sources},         {"{{filters}}", _filters},
+		{"{{actions}}", _actions},         {"{{settings}}", _settings},
+		{"{{getSettings}}", _getSettings},
+	};
+	placeWidgets(obs_module_text("AdvSceneSwitcher.action.filter.entry"),
+		     entryLayout, widgetPlaceholders);
+
+	QHBoxLayout *buttonLayout = new QHBoxLayout;
+	buttonLayout->addWidget(_getSettings);
+	buttonLayout->addStretch();
+
+	QVBoxLayout *mainLayout = new QVBoxLayout;
+	mainLayout->addLayout(entryLayout);
+	mainLayout->addWidget(_settings);
+	mainLayout->addLayout(buttonLayout);
+	setLayout(mainLayout);
+
+	_entryData = entryData;
+	UpdateEntryData();
+	_loading = false;
+}
+
+void MacroActionFilterEdit::UpdateEntryData()
+{
+	if (!_entryData) {
+		return;
+	}
+
+	_actions->setCurrentIndex(static_cast<int>(_entryData->_action));
+	_sources->setCurrentText(
+		GetWeakSourceName(_entryData->_source).c_str());
+	populateFilterSelection(_filters, _entryData->_source);
+	_filters->setCurrentText(
+		GetWeakSourceName(_entryData->_filter).c_str());
+	_settings->setPlainText(QString::fromStdString(_entryData->_settings));
+	SetWidgetVisibility(_entryData->_action == FilterAction::SETTINGS);
+}
+
+void MacroActionFilterEdit::SourceChanged(const QString &text)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+	{
+		std::lock_guard<std::mutex> lock(switcher->m);
+		_entryData->_source = GetWeakSourceByQString(text);
+	}
+	_filters->clear();
+	populateFilterSelection(_filters, _entryData->_source);
+}
+
+void MacroActionFilterEdit::FilterChanged(const QString &text)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_filter = GetWeakFilterByQString(_entryData->_source, text);
+	emit HeaderInfoChanged(
+		QString::fromStdString(_entryData->GetShortDesc()));
+}
+
+void MacroActionFilterEdit::ActionChanged(int value)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_action = static_cast<FilterAction>(value);
+	SetWidgetVisibility(_entryData->_action == FilterAction::SETTINGS);
+}
+
+void MacroActionFilterEdit::GetSettingsClicked()
+{
+	if (_loading || !_entryData || !_entryData->_source ||
+	    !_entryData->_filter) {
+		return;
+	}
+
+	_settings->setPlainText(
+		formatJsonString(getSourceSettings(_entryData->_filter)));
+}
+
+void MacroActionFilterEdit::SettingsChanged()
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_settings = _settings->toPlainText().toStdString();
+}
+
+void MacroActionFilterEdit::SetWidgetVisibility(bool showSettings)
+{
+	_settings->setVisible(showSettings);
+	_getSettings->setVisible(showSettings);
+	adjustSize();
+}

src/macro-action-hotkey.cpp

@@ -0,0 +1,377 @@
+#include "headers/macro-action-hotkey.hpp"
+#include "headers/advanced-scene-switcher.hpp"
+#include "headers/utility.hpp"
+
+const std::string MacroActionHotkey::id = "hotkey";
+
+// TODO:
+// I can't seem to get this to work so drop support for this functionality
+// on MacOS
+#if !__APPLE__
+bool MacroActionHotkey::_registered = MacroActionFactory::Register(
+	MacroActionHotkey::id,
+	{MacroActionHotkey::Create, MacroActionHotkeyEdit::Create,
+	 "AdvSceneSwitcher.action.hotkey"});
+#endif
+
+bool MacroActionHotkey::PerformAction()
+{
+	std::vector<HotkeyType> keys;
+	if (_leftShift) {
+		keys.push_back(HotkeyType::Key_Shift_L);
+	}
+	if (_rightShift) {
+		keys.push_back(HotkeyType::Key_Shift_R);
+	}
+	if (_leftCtrl) {
+		keys.push_back(HotkeyType::Key_Control_L);
+	}
+	if (_rightCtrl) {
+		keys.push_back(HotkeyType::Key_Control_R);
+	}
+	if (_leftAlt) {
+		keys.push_back(HotkeyType::Key_Alt_L);
+	}
+	if (_rightAlt) {
+		keys.push_back(HotkeyType::Key_Alt_R);
+	}
+	if (_key != HotkeyType::Key_NoKey) {
+		keys.push_back(_key);
+	}
+
+	if (!keys.empty()) {
+		std::thread t([keys]() { PressKeys(keys); });
+		t.detach();
+	}
+
+	return true;
+}
+
+void MacroActionHotkey::LogAction()
+{
+	vblog(LOG_INFO, "sent hotkey");
+}
+
+bool MacroActionHotkey::Save(obs_data_t *obj)
+{
+	MacroAction::Save(obj);
+	obs_data_set_int(obj, "key", static_cast<int>(_key));
+	obs_data_set_bool(obj, "left_shift", _leftShift);
+	obs_data_set_bool(obj, "right_shift", _rightShift);
+	obs_data_set_bool(obj, "left_ctrl", _leftCtrl);
+	obs_data_set_bool(obj, "right_ctrl", _rightCtrl);
+	obs_data_set_bool(obj, "left_alt", _leftAlt);
+	obs_data_set_bool(obj, "right_alt", _rightAlt);
+	obs_data_set_bool(obj, "left_meta", _leftMeta);
+	obs_data_set_bool(obj, "right_meta", _rightMeta);
+	return true;
+}
+
+bool MacroActionHotkey::Load(obs_data_t *obj)
+{
+	MacroAction::Load(obj);
+	_key = static_cast<HotkeyType>(obs_data_get_int(obj, "key"));
+	_leftShift = obs_data_get_bool(obj, "left_shift");
+	_rightShift = obs_data_get_bool(obj, "right_shift");
+	_leftCtrl = obs_data_get_bool(obj, "left_ctrl");
+	_rightCtrl = obs_data_get_bool(obj, "right_ctrl");
+	_leftAlt = obs_data_get_bool(obj, "left_alt");
+	_rightAlt = obs_data_get_bool(obj, "right_alt");
+	_leftMeta = obs_data_get_bool(obj, "left_meta");
+	_rightMeta = obs_data_get_bool(obj, "right_meta");
+	return true;
+}
+
+static inline void populateKeySelection(QComboBox *list)
+{
+	list->addItem("No key");
+	list->addItem("A");
+	list->addItem("B");
+	list->addItem("C");
+	list->addItem("D");
+	list->addItem("E");
+	list->addItem("F");
+	list->addItem("G");
+	list->addItem("H");
+	list->addItem("I");
+	list->addItem("J");
+	list->addItem("K");
+	list->addItem("L");
+	list->addItem("M");
+	list->addItem("N");
+	list->addItem("O");
+	list->addItem("P");
+	list->addItem("Q");
+	list->addItem("R");
+	list->addItem("S");
+	list->addItem("T");
+	list->addItem("U");
+	list->addItem("V");
+	list->addItem("W");
+	list->addItem("X");
+	list->addItem("Y");
+	list->addItem("Z");
+	list->addItem("0");
+	list->addItem("1");
+	list->addItem("2");
+	list->addItem("3");
+	list->addItem("4");
+	list->addItem("5");
+	list->addItem("6");
+	list->addItem("7");
+	list->addItem("8");
+	list->addItem("9");
+	list->addItem("F1");
+	list->addItem("F2");
+	list->addItem("F3");
+	list->addItem("F4");
+	list->addItem("F5");
+	list->addItem("F6");
+	list->addItem("F7");
+	list->addItem("F8");
+	list->addItem("F9");
+	list->addItem("F10");
+	list->addItem("F11");
+	list->addItem("F12");
+	list->addItem("F13");
+	list->addItem("F14");
+	list->addItem("F15");
+	list->addItem("F16");
+	list->addItem("F17");
+	list->addItem("F18");
+	list->addItem("F19");
+	list->addItem("F20");
+	list->addItem("F21");
+	list->addItem("F22");
+	list->addItem("F23");
+	list->addItem("F24");
+	list->addItem("Escape");
+	list->addItem("Space");
+	list->addItem("Return");
+	list->addItem("Backspace");
+	list->addItem("Tab");
+	list->addItem("Shift_L");
+	list->addItem("Shift_R");
+	list->addItem("Control_L");
+	list->addItem("Control_R");
+	list->addItem("Alt_L");
+	list->addItem("Alt_R");
+	list->addItem("Win_L");
+	list->addItem("Win_R");
+	list->addItem("Apps");
+	list->addItem("CapsLock");
+	list->addItem("NumLock");
+	list->addItem("ScrollLock");
+	list->addItem("PrintScreen");
+	list->addItem("Pause");
+	list->addItem("Insert");
+	list->addItem("Delete");
+	list->addItem("PageUP");
+	list->addItem("PageDown");
+	list->addItem("Home");
+	list->addItem("End");
+	list->addItem("Left");
+	list->addItem("Right");
+	list->addItem("Up");
+	list->addItem("Down");
+	list->addItem("Numpad0");
+	list->addItem("Numpad1");
+	list->addItem("Numpad2");
+	list->addItem("Numpad3");
+	list->addItem("Numpad4");
+	list->addItem("Numpad5");
+	list->addItem("Numpad6");
+	list->addItem("Numpad7");
+	list->addItem("Numpad8");
+	list->addItem("Numpad9");
+	list->addItem("NumpadAdd");
+	list->addItem("NumpadSubtract");
+	list->addItem("NumpadMultiply");
+	list->addItem("NumpadDivide");
+	list->addItem("NumpadDecimal");
+	list->addItem("NumpadEnter");
+}
+
+MacroActionHotkeyEdit::MacroActionHotkeyEdit(
+	QWidget *parent, std::shared_ptr<MacroActionHotkey> entryData)
+	: QWidget(parent)
+{
+	_keys = new QComboBox();
+	_leftShift = new QCheckBox(
+		obs_module_text("AdvSceneSwitcher.action.hotkey.leftShift"));
+	_rightShift = new QCheckBox(
+		obs_module_text("AdvSceneSwitcher.action.hotkey.rightShift"));
+	_leftCtrl = new QCheckBox(
+		obs_module_text("AdvSceneSwitcher.action.hotkey.leftCtrl"));
+	_rightCtrl = new QCheckBox(
+		obs_module_text("AdvSceneSwitcher.action.hotkey.rightCtrl"));
+	_leftAlt = new QCheckBox(
+		obs_module_text("AdvSceneSwitcher.action.hotkey.leftAlt"));
+	_rightAlt = new QCheckBox(
+		obs_module_text("AdvSceneSwitcher.action.hotkey.rightAlt"));
+	_leftMeta = new QCheckBox(
+		obs_module_text("AdvSceneSwitcher.action.hotkey.leftMeta"));
+	_rightMeta = new QCheckBox(
+		obs_module_text("AdvSceneSwitcher.action.hotkey.rightMeta"));
+
+	populateKeySelection(_keys);
+
+	QWidget::connect(_keys, SIGNAL(currentIndexChanged(int)), this,
+			 SLOT(KeyChanged(int)));
+	QWidget::connect(_leftShift, SIGNAL(stateChanged(int)), this,
+			 SLOT(LShiftChanged(int)));
+	QWidget::connect(_rightShift, SIGNAL(stateChanged(int)), this,
+			 SLOT(RShiftChanged(int)));
+	QWidget::connect(_leftCtrl, SIGNAL(stateChanged(int)), this,
+			 SLOT(LCtrlChanged(int)));
+	QWidget::connect(_rightCtrl, SIGNAL(stateChanged(int)), this,
+			 SLOT(RCtrlChanged(int)));
+	QWidget::connect(_leftAlt, SIGNAL(stateChanged(int)), this,
+			 SLOT(LAltChanged(int)));
+	QWidget::connect(_rightAlt, SIGNAL(stateChanged(int)), this,
+			 SLOT(RAltChanged(int)));
+	QWidget::connect(_leftMeta, SIGNAL(stateChanged(int)), this,
+			 SLOT(LMetaChanged(int)));
+	QWidget::connect(_rightMeta, SIGNAL(stateChanged(int)), this,
+			 SLOT(RMetaChanged(int)));
+
+	QHBoxLayout *line1Layout = new QHBoxLayout;
+	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
+		{"{{keys}}", _keys},
+	};
+	placeWidgets(obs_module_text("AdvSceneSwitcher.action.hotkey.entry"),
+		     line1Layout, widgetPlaceholders);
+
+	QHBoxLayout *line2Layout = new QHBoxLayout;
+	line2Layout->addWidget(_leftShift);
+	line2Layout->addWidget(_rightShift);
+	line2Layout->addWidget(_leftCtrl);
+	line2Layout->addWidget(_rightCtrl);
+	line2Layout->addWidget(_leftAlt);
+	line2Layout->addWidget(_rightAlt);
+	line2Layout->addWidget(_leftMeta);
+	line2Layout->addWidget(_rightMeta);
+	line2Layout->addStretch();
+
+	QVBoxLayout *mainLayout = new QVBoxLayout;
+	mainLayout->addLayout(line1Layout);
+	mainLayout->addLayout(line2Layout);
+
+	if (!canSimulateKeyPresses) {
+		mainLayout->addWidget(new QLabel(obs_module_text(
+			"AdvSceneSwitcher.action.hotkey.disabled")));
+	}
+
+	setLayout(mainLayout);
+
+	_entryData = entryData;
+	UpdateEntryData();
+	_loading = false;
+}
+
+void MacroActionHotkeyEdit::UpdateEntryData()
+{
+	if (!_entryData) {
+		return;
+	}
+
+	_keys->setCurrentIndex(static_cast<int>(_entryData->_key));
+	_leftShift->setChecked(_entryData->_leftShift);
+	_rightShift->setChecked(_entryData->_rightShift);
+	_leftCtrl->setChecked(_entryData->_leftCtrl);
+	_rightCtrl->setChecked(_entryData->_rightCtrl);
+	_leftAlt->setChecked(_entryData->_leftAlt);
+	_rightAlt->setChecked(_entryData->_rightAlt);
+	_leftMeta->setChecked(_entryData->_leftMeta);
+	_rightMeta->setChecked(_entryData->_rightMeta);
+}
+
+void MacroActionHotkeyEdit::LShiftChanged(int state)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_leftShift = state;
+}
+
+void MacroActionHotkeyEdit::RShiftChanged(int state)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_rightShift = state;
+}
+
+void MacroActionHotkeyEdit::LCtrlChanged(int state)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_leftCtrl = state;
+}
+
+void MacroActionHotkeyEdit::RCtrlChanged(int state)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_rightCtrl = state;
+}
+
+void MacroActionHotkeyEdit::LAltChanged(int state)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_leftAlt = state;
+}
+
+void MacroActionHotkeyEdit::RAltChanged(int state)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_rightAlt = state;
+}
+
+void MacroActionHotkeyEdit::LMetaChanged(int state)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_leftMeta = state;
+}
+
+void MacroActionHotkeyEdit::RMetaChanged(int state)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_rightMeta = state;
+}
+
+void MacroActionHotkeyEdit::KeyChanged(int key)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_key = static_cast<HotkeyType>(key);
+}

src/macro-action-macro.cpp

@@ -0,0 +1,162 @@
+#include "headers/macro-action-macro.hpp"
+#include "headers/advanced-scene-switcher.hpp"
+#include "headers/utility.hpp"
+
+const std::string MacroActionMacro::id = "macro";
+
+bool MacroActionMacro::_registered = MacroActionFactory::Register(
+	MacroActionMacro::id,
+	{MacroActionMacro::Create, MacroActionMacroEdit::Create,
+	 "AdvSceneSwitcher.action.macro"});
+
+const static std::map<PerformMacroAction, std::string> actionTypes = {
+	{PerformMacroAction::PAUSE, "AdvSceneSwitcher.action.macro.type.pause"},
+	{PerformMacroAction::UNPAUSE,
+	 "AdvSceneSwitcher.action.macro.type.unpause"},
+	{PerformMacroAction::RESET_COUNTER,
+	 "AdvSceneSwitcher.action.macro.type.resetCounter"},
+};
+
+bool MacroActionMacro::PerformAction()
+{
+	if (!_macro.get()) {
+		return true;
+	}
+
+	switch (_action) {
+	case PerformMacroAction::PAUSE:
+		_macro->SetPaused();
+		break;
+	case PerformMacroAction::UNPAUSE:
+		_macro->SetPaused(false);
+		break;
+	case PerformMacroAction::RESET_COUNTER:
+		_macro->ResetCount();
+		break;
+	default:
+		break;
+	}
+	return true;
+}
+
+void MacroActionMacro::LogAction()
+{
+	if (!_macro.get()) {
+		return;
+	}
+	switch (_action) {
+	case PerformMacroAction::PAUSE:
+		vblog(LOG_INFO, "paused \"%s\"", _macro->Name().c_str());
+		break;
+	case PerformMacroAction::UNPAUSE:
+		vblog(LOG_INFO, "unpaused \"%s\"", _macro->Name().c_str());
+		break;
+	case PerformMacroAction::RESET_COUNTER:
+		vblog(LOG_INFO, "reset counter for \"%s\"",
+		      _macro->Name().c_str());
+		break;
+	default:
+		break;
+	}
+}
+
+bool MacroActionMacro::Save(obs_data_t *obj)
+{
+	MacroAction::Save(obj);
+	_macro.Save(obj);
+	obs_data_set_int(obj, "action", static_cast<int>(_action));
+	return true;
+}
+
+bool MacroActionMacro::Load(obs_data_t *obj)
+{
+	MacroAction::Load(obj);
+	_macro.Load(obj);
+	_action = static_cast<PerformMacroAction>(
+		obs_data_get_int(obj, "action"));
+	return true;
+}
+
+std::string MacroActionMacro::GetShortDesc()
+{
+	if (_macro.get()) {
+		return _macro->Name();
+	}
+	return "";
+}
+
+static inline void populateActionSelection(QComboBox *list)
+{
+	for (auto entry : actionTypes) {
+		list->addItem(obs_module_text(entry.second.c_str()));
+	}
+}
+
+MacroActionMacroEdit::MacroActionMacroEdit(
+	QWidget *parent, std::shared_ptr<MacroActionMacro> entryData)
+	: QWidget(parent)
+{
+	_macros = new MacroSelection(parent);
+	_actions = new QComboBox();
+
+	populateActionSelection(_actions);
+
+	QWidget::connect(_macros, SIGNAL(currentTextChanged(const QString &)),
+			 this, SLOT(MacroChanged(const QString &)));
+	QWidget::connect(parent, SIGNAL(MacroRemoved(const QString &)), this,
+			 SLOT(MacroRemove(const QString &)));
+	QWidget::connect(_actions, SIGNAL(currentIndexChanged(int)), this,
+			 SLOT(ActionChanged(int)));
+
+	QHBoxLayout *mainLayout = new QHBoxLayout;
+	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
+		{"{{actions}}", _actions},
+		{"{{macros}}", _macros},
+	};
+	placeWidgets(obs_module_text("AdvSceneSwitcher.action.macro.entry"),
+		     mainLayout, widgetPlaceholders);
+	setLayout(mainLayout);
+
+	_entryData = entryData;
+	UpdateEntryData();
+	_loading = false;
+}
+
+void MacroActionMacroEdit::UpdateEntryData()
+{
+	if (!_entryData) {
+		return;
+	}
+	_actions->setCurrentIndex(static_cast<int>(_entryData->_action));
+	_macros->SetCurrentMacro(_entryData->_macro.get());
+}
+
+void MacroActionMacroEdit::MacroChanged(const QString &text)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_macro.UpdateRef(text);
+	emit HeaderInfoChanged(
+		QString::fromStdString(_entryData->GetShortDesc()));
+}
+
+void MacroActionMacroEdit::ActionChanged(int value)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_action = static_cast<PerformMacroAction>(value);
+}
+
+void MacroActionMacroEdit::MacroRemove(const QString &name)
+{
+	UNUSED_PARAMETER(name);
+	if (_entryData) {
+		_entryData->_macro.UpdateRef();
+	}
+}

src/macro-action-media.cpp

@@ -0,0 +1,163 @@
+#include "headers/macro-action-media.hpp"
+#include "headers/advanced-scene-switcher.hpp"
+#include "headers/utility.hpp"
+
+const std::string MacroActionMedia::id = "media";
+
+bool MacroActionMedia::_registered = MacroActionFactory::Register(
+	MacroActionMedia::id,
+	{MacroActionMedia::Create, MacroActionMediaEdit::Create,
+	 "AdvSceneSwitcher.action.media"});
+
+const static std::map<MediaAction, std::string> actionTypes = {
+	{MediaAction::PLAY, "AdvSceneSwitcher.action.media.type.play"},
+	{MediaAction::PAUSE, "AdvSceneSwitcher.action.media.type.pause"},
+	{MediaAction::STOP, "AdvSceneSwitcher.action.media.type.stop"},
+	{MediaAction::RESTART, "AdvSceneSwitcher.action.media.type.restart"},
+	{MediaAction::NEXT, "AdvSceneSwitcher.action.media.type.next"},
+	{MediaAction::PREVIOUS, "AdvSceneSwitcher.action.media.type.previous"},
+};
+
+bool MacroActionMedia::PerformAction()
+{
+	auto source = obs_weak_source_get_source(_mediaSource);
+	obs_media_state state = obs_source_media_get_state(source);
+	switch (_action) {
+	case MediaAction::PLAY:
+		if (state == OBS_MEDIA_STATE_STOPPED ||
+		    state == OBS_MEDIA_STATE_ENDED) {
+			obs_source_media_restart(source);
+		} else {
+			obs_source_media_play_pause(source, false);
+		}
+		break;
+	case MediaAction::PAUSE:
+		obs_source_media_play_pause(source, true);
+		break;
+	case MediaAction::STOP:
+		obs_source_media_stop(source);
+		break;
+	case MediaAction::RESTART:
+		obs_source_media_restart(source);
+		break;
+	case MediaAction::NEXT:
+		obs_source_media_next(source);
+		break;
+	case MediaAction::PREVIOUS:
+		obs_source_media_previous(source);
+		break;
+	default:
+		break;
+	}
+	obs_source_release(source);
+	return true;
+}
+
+void MacroActionMedia::LogAction()
+{
+	auto it = actionTypes.find(_action);
+	if (it != actionTypes.end()) {
+		vblog(LOG_INFO, "performed action \"%s\" for source \"%s\"",
+		      it->second.c_str(),
+		      GetWeakSourceName(_mediaSource).c_str());
+	} else {
+		blog(LOG_WARNING, "ignored unknown media action %d",
+		     static_cast<int>(_action));
+	}
+}
+
+bool MacroActionMedia::Save(obs_data_t *obj)
+{
+	MacroAction::Save(obj);
+	obs_data_set_string(obj, "mediaSource",
+			    GetWeakSourceName(_mediaSource).c_str());
+	obs_data_set_int(obj, "action", static_cast<int>(_action));
+	return true;
+}
+
+bool MacroActionMedia::Load(obs_data_t *obj)
+{
+	MacroAction::Load(obj);
+	const char *MediaSourceName = obs_data_get_string(obj, "mediaSource");
+	_mediaSource = GetWeakSourceByName(MediaSourceName);
+	_action = static_cast<MediaAction>(obs_data_get_int(obj, "action"));
+	return true;
+}
+
+std::string MacroActionMedia::GetShortDesc()
+{
+	if (_mediaSource) {
+		return GetWeakSourceName(_mediaSource);
+	}
+	return "";
+}
+
+static inline void populateActionSelection(QComboBox *list)
+{
+	for (auto entry : actionTypes) {
+		list->addItem(obs_module_text(entry.second.c_str()));
+	}
+}
+
+MacroActionMediaEdit::MacroActionMediaEdit(
+	QWidget *parent, std::shared_ptr<MacroActionMedia> entryData)
+	: QWidget(parent)
+{
+	_mediaSources = new QComboBox();
+	_actions = new QComboBox();
+
+	populateActionSelection(_actions);
+	populateMediaSelection(_mediaSources);
+
+	QWidget::connect(_actions, SIGNAL(currentIndexChanged(int)), this,
+			 SLOT(ActionChanged(int)));
+	QWidget::connect(_mediaSources,
+			 SIGNAL(currentTextChanged(const QString &)), this,
+			 SLOT(SourceChanged(const QString &)));
+
+	QHBoxLayout *mainLayout = new QHBoxLayout;
+	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
+		{"{{mediaSources}}", _mediaSources},
+		{"{{actions}}", _actions},
+	};
+	placeWidgets(obs_module_text("AdvSceneSwitcher.action.media.entry"),
+		     mainLayout, widgetPlaceholders);
+	setLayout(mainLayout);
+
+	_entryData = entryData;
+	UpdateEntryData();
+	_loading = false;
+}
+
+void MacroActionMediaEdit::UpdateEntryData()
+{
+	if (!_entryData) {
+		return;
+	}
+
+	_mediaSources->setCurrentText(
+		GetWeakSourceName(_entryData->_mediaSource).c_str());
+	_actions->setCurrentIndex(static_cast<int>(_entryData->_action));
+}
+
+void MacroActionMediaEdit::SourceChanged(const QString &text)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_mediaSource = GetWeakSourceByQString(text);
+	emit HeaderInfoChanged(
+		QString::fromStdString(_entryData->GetShortDesc()));
+}
+
+void MacroActionMediaEdit::ActionChanged(int value)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_action = static_cast<MediaAction>(value);
+}

src/macro-action-plugin-state.cpp

@@ -0,0 +1,203 @@
+#include "headers/macro-action-plugin-state.hpp"
+#include "headers/advanced-scene-switcher.hpp"
+#include "headers/utility.hpp"
+
+#include <thread>
+
+const std::string MacroActionPluginState::id = "plugin_state";
+
+bool MacroActionPluginState::_registered = MacroActionFactory::Register(
+	MacroActionPluginState::id,
+	{MacroActionPluginState::Create, MacroActionPluginStateEdit::Create,
+	 "AdvSceneSwitcher.action.PluginState"});
+
+const static std::map<PluginStateAction, std::string> actionTypes = {
+	{PluginStateAction::STOP,
+	 "AdvSceneSwitcher.action.pluginState.type.stop"},
+	{PluginStateAction::NO_MATCH_BEHAVIOUR,
+	 "AdvSceneSwitcher.action.pluginState.type.noMatch"},
+};
+
+const static std::map<NoMatch, std::string> noMatchValues = {
+	{NO_SWITCH,
+	 "AdvSceneSwitcher.generalTab.generalBehavior.onNoMet.dontSwitch"},
+	{SWITCH,
+	 "AdvSceneSwitcher.generalTab.generalBehavior.onNoMet.switchTo"},
+	{RANDOM_SWITCH,
+	 "AdvSceneSwitcher.generalTab.generalBehavior.onNoMet.switchToRandom"},
+};
+
+void stopPlugin()
+{
+	std::thread t([]() { switcher->Stop(); });
+	t.detach();
+}
+
+void setNoMatchBehaviour(int value, OBSWeakSource &scene)
+{
+	switcher->switchIfNotMatching = static_cast<NoMatch>(value);
+	if (switcher->switchIfNotMatching == SWITCH) {
+		switcher->nonMatchingScene = scene;
+	}
+}
+
+bool MacroActionPluginState::PerformAction()
+{
+	switch (_action) {
+	case PluginStateAction::STOP:
+		stopPlugin();
+		break;
+	case PluginStateAction::NO_MATCH_BEHAVIOUR:
+		setNoMatchBehaviour(_value, _scene);
+		break;
+	default:
+		break;
+	}
+	return true;
+}
+
+void MacroActionPluginState::LogAction()
+{
+	switch (_action) {
+	case PluginStateAction::STOP:
+		blog(LOG_INFO, "stop() called by macro");
+		break;
+	default:
+		blog(LOG_WARNING, "ignored unknown pluginState action %d",
+		     static_cast<int>(_action));
+		break;
+	}
+}
+
+bool MacroActionPluginState::Save(obs_data_t *obj)
+{
+	MacroAction::Save(obj);
+	obs_data_set_int(obj, "action", static_cast<int>(_action));
+	obs_data_set_int(obj, "value", _value);
+	obs_data_set_string(obj, "scene", GetWeakSourceName(_scene).c_str());
+	return true;
+}
+
+bool MacroActionPluginState::Load(obs_data_t *obj)
+{
+	MacroAction::Load(obj);
+	_action =
+		static_cast<PluginStateAction>(obs_data_get_int(obj, "action"));
+	_value = obs_data_get_int(obj, "value");
+	const char *sceneName = obs_data_get_string(obj, "scene");
+	_scene = GetWeakSourceByName(sceneName);
+	return true;
+}
+
+static inline void populateActionSelection(QComboBox *list)
+{
+	for (auto entry : actionTypes) {
+		list->addItem(obs_module_text(entry.second.c_str()));
+	}
+}
+
+static inline void populateValueSelection(QComboBox *list,
+					  PluginStateAction action)
+{
+	if (action == PluginStateAction::NO_MATCH_BEHAVIOUR) {
+		for (auto entry : noMatchValues) {
+			list->addItem(obs_module_text(entry.second.c_str()));
+		}
+	}
+}
+
+MacroActionPluginStateEdit::MacroActionPluginStateEdit(
+	QWidget *parent, std::shared_ptr<MacroActionPluginState> entryData)
+	: QWidget(parent)
+{
+	_actions = new QComboBox();
+	_values = new QComboBox();
+	_scenes = new QComboBox();
+
+	populateActionSelection(_actions);
+	populateSceneSelection(_scenes);
+
+	QWidget::connect(_actions, SIGNAL(currentIndexChanged(int)), this,
+			 SLOT(ActionChanged(int)));
+	QWidget::connect(_values, SIGNAL(currentIndexChanged(int)), this,
+			 SLOT(ValueChanged(int)));
+	QWidget::connect(_scenes, SIGNAL(currentTextChanged(const QString &)),
+			 this, SLOT(SceneChanged(const QString &)));
+
+	QHBoxLayout *mainLayout = new QHBoxLayout;
+	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
+		{"{{actions}}", _actions},
+		{"{{values}}", _values},
+		{"{{scenes}}", _scenes},
+	};
+	placeWidgets(
+		obs_module_text("AdvSceneSwitcher.action.pluginState.entry"),
+		mainLayout, widgetPlaceholders);
+	setLayout(mainLayout);
+
+	_entryData = entryData;
+	UpdateEntryData();
+	_loading = false;
+}
+
+void MacroActionPluginStateEdit::UpdateEntryData()
+{
+	if (!_entryData) {
+		return;
+	}
+	_actions->setCurrentIndex(static_cast<int>(_entryData->_action));
+	populateValueSelection(_values, _entryData->_action);
+	_values->setCurrentIndex(_entryData->_value);
+	_scenes->setCurrentText(GetWeakSourceName(_entryData->_scene).c_str());
+	SetWidgetVisibility(_entryData->_action, _entryData->_value);
+}
+
+void MacroActionPluginStateEdit::ActionChanged(int value)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	{
+		std::lock_guard<std::mutex> lock(switcher->m);
+		_entryData->_action = static_cast<PluginStateAction>(value);
+		SetWidgetVisibility(_entryData->_action, _entryData->_value);
+	}
+
+	_values->clear();
+	populateValueSelection(_values, _entryData->_action);
+}
+
+void MacroActionPluginStateEdit::ValueChanged(int value)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_value = value;
+	SetWidgetVisibility(_entryData->_action, _entryData->_value);
+}
+
+void MacroActionPluginStateEdit::SceneChanged(const QString &text)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_scene = GetWeakSourceByQString(text);
+}
+
+void MacroActionPluginStateEdit::SetWidgetVisibility(PluginStateAction action,
+						     int value)
+{
+	_values->hide();
+	_scenes->hide();
+	if (action == PluginStateAction::NO_MATCH_BEHAVIOUR) {
+		_values->show();
+		if ((NoMatch)value == SWITCH) {
+			_scenes->show();
+		}
+	}
+}

src/macro-action-recording.cpp

@@ -2,7 +2,7 @@
 #include "headers/advanced-scene-switcher.hpp"
 #include "headers/utility.hpp"
 
-const int MacroActionRecord::id = 4;
+const std::string MacroActionRecord::id = "recording";
 
 bool MacroActionRecord::_registered = MacroActionFactory::Register(
 	MacroActionRecord::id,

src/macro-action-replay-buffer.cpp

@@ -2,7 +2,7 @@
 #include "headers/advanced-scene-switcher.hpp"
 #include "headers/utility.hpp"
 
-const int MacroActionReplayBuffer::id = 5;
+const std::string MacroActionReplayBuffer::id = "replay_buffer";
 
 bool MacroActionReplayBuffer::_registered = MacroActionFactory::Register(
 	MacroActionReplayBuffer::id,

src/macro-action-run.cpp

@@ -1,11 +1,12 @@
 #include "headers/macro-action-run.hpp"
 #include "headers/advanced-scene-switcher.hpp"
+#include "headers/name-dialog.hpp"
 #include "headers/utility.hpp"
 
 #include <QProcess>
 #include <QFileDialog>
 
-const int MacroActionRun::id = 6;
+const std::string MacroActionRun::id = "run";
 
 bool MacroActionRun::_registered = MacroActionFactory::Register(
 	MacroActionRun::id, {MacroActionRun::Create, MacroActionRunEdit::Create,
@@ -13,7 +14,7 @@ bool MacroActionRun::_registered = MacroActionFactory::Register(
 
 bool MacroActionRun::PerformAction()
 {
-	QProcess::startDetached(QString::fromStdString(_path), QStringList());
+	QProcess::startDetached(QString::fromStdString(_path), _args);
 	return true;
 }
 
@@ -26,6 +27,16 @@ bool MacroActionRun::Save(obs_data_t *obj)
 {
 	MacroAction::Save(obj);
 	obs_data_set_string(obj, "path", _path.c_str());
+	obs_data_array_t *args = obs_data_array_create();
+	for (auto &arg : _args) {
+		obs_data_t *array_obj = obs_data_create();
+		obs_data_set_string(array_obj, "arg",
+				    arg.toStdString().c_str());
+		obs_data_array_push_back(args, array_obj);
+		obs_data_release(array_obj);
+	}
+	obs_data_set_array(obj, "args", args);
+	obs_data_array_release(args);
 	return true;
 }
 
@@ -33,9 +44,23 @@ bool MacroActionRun::Load(obs_data_t *obj)
 {
 	MacroAction::Load(obj);
 	_path = obs_data_get_string(obj, "path");
+	obs_data_array_t *args = obs_data_get_array(obj, "args");
+	size_t count = obs_data_array_count(args);
+	for (size_t i = 0; i < count; i++) {
+		obs_data_t *array_obj = obs_data_array_item(args, i);
+		_args << QString::fromStdString(
+			obs_data_get_string(array_obj, "arg"));
+		obs_data_release(array_obj);
+	}
+	obs_data_array_release(args);
 	return true;
 }
 
+std::string MacroActionRun::GetShortDesc()
+{
+	return _path;
+}
+
 MacroActionRunEdit::MacroActionRunEdit(
 	QWidget *parent, std::shared_ptr<MacroActionRun> entryData)
 	: QWidget(parent)
@@ -43,20 +68,63 @@ MacroActionRunEdit::MacroActionRunEdit(
 	_filePath = new QLineEdit();
 	_browseButton =
 		new QPushButton(obs_module_text("AdvSceneSwitcher.browse"));
-	_browseButton->setStyleSheet("border:1px solid gray;");
+	_argList = new QListWidget();
+	_addArg = new QPushButton();
+	_addArg->setMaximumSize(QSize(22, 22));
+	_addArg->setProperty("themeID",
+			     QVariant(QString::fromUtf8("addIconSmall")));
+	_addArg->setFlat(true);
+	_removeArg = new QPushButton();
+	_removeArg->setMaximumSize(QSize(22, 22));
+	_removeArg->setProperty("themeID",
+				QVariant(QString::fromUtf8("removeIconSmall")));
+	_removeArg->setFlat(true);
+	_argUp = new QPushButton();
+	_argUp->setMaximumSize(QSize(22, 22));
+	_argUp->setProperty("themeID",
+			    QVariant(QString::fromUtf8("upArrowIconSmall")));
+	_argUp->setFlat(true);
+	_argDown = new QPushButton();
+	_argDown->setMaximumSize(QSize(22, 22));
+	_argDown->setProperty(
+		"themeID", QVariant(QString::fromUtf8("downArrowIconSmall")));
+	_argDown->setFlat(true);
 
 	QWidget::connect(_filePath, SIGNAL(editingFinished()), this,
 			 SLOT(FilePathChanged()));
 	QWidget::connect(_browseButton, SIGNAL(clicked()), this,
 			 SLOT(BrowseButtonClicked()));
+	QWidget::connect(_addArg, SIGNAL(clicked()), this, SLOT(AddArg()));
+	QWidget::connect(_removeArg, SIGNAL(clicked()), this,
+			 SLOT(RemoveArg()));
+	QWidget::connect(_argUp, SIGNAL(clicked()), this, SLOT(ArgUp()));
+	QWidget::connect(_argDown, SIGNAL(clicked()), this, SLOT(ArgDown()));
 
-	QHBoxLayout *mainLayout = new QHBoxLayout;
+	auto *entryLayout = new QHBoxLayout;
 	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
 		{"{{filePath}}", _filePath},
 		{"{{browseButton}}", _browseButton},
 	};
 	placeWidgets(obs_module_text("AdvSceneSwitcher.action.run.entry"),
-		     mainLayout, widgetPlaceholders);
+		     entryLayout, widgetPlaceholders);
+
+	auto *argButtonLayout = new QHBoxLayout;
+	argButtonLayout->addWidget(_addArg);
+	argButtonLayout->addWidget(_removeArg);
+	QFrame *line = new QFrame();
+	line->setFrameShape(QFrame::VLine);
+	line->setFrameShadow(QFrame::Sunken);
+	argButtonLayout->addWidget(line);
+	argButtonLayout->addWidget(_argUp);
+	argButtonLayout->addWidget(_argDown);
+	argButtonLayout->addStretch();
+
+	auto *mainLayout = new QVBoxLayout;
+	mainLayout->addLayout(entryLayout);
+	mainLayout->addWidget(new QLabel(
+		obs_module_text("AdvSceneSwitcher.action.run.arguments")));
+	mainLayout->addWidget(_argList);
+	mainLayout->addLayout(argButtonLayout);
 	setLayout(mainLayout);
 
 	_entryData = entryData;
@@ -70,6 +138,10 @@ void MacroActionRunEdit::UpdateEntryData()
 		return;
 	}
 	_filePath->setText(QString::fromStdString(_entryData->_path));
+	for (auto &arg : _entryData->_args) {
+		QListWidgetItem *item = new QListWidgetItem(arg, _argList);
+		item->setData(Qt::UserRole, arg);
+	}
 }
 
 void MacroActionRunEdit::FilePathChanged()
@@ -80,6 +152,8 @@ void MacroActionRunEdit::FilePathChanged()
 
 	std::lock_guard<std::mutex> lock(switcher->m);
 	_entryData->_path = _filePath->text().toUtf8().constData();
+	emit HeaderInfoChanged(
+		QString::fromStdString(_entryData->GetShortDesc()));
 }
 
 void MacroActionRunEdit::BrowseButtonClicked()
@@ -96,3 +170,77 @@ void MacroActionRunEdit::BrowseButtonClicked()
 	_filePath->setText(path);
 	FilePathChanged();
 }
+
+void MacroActionRunEdit::AddArg()
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::string name;
+	bool accepted = AdvSSNameDialog::AskForName(
+		this,
+		obs_module_text("AdvSceneSwitcher.action.run.addArgument"),
+		obs_module_text(
+			"AdvSceneSwitcher.action.run.addArgumentDescription"),
+		name, "", 170, false);
+
+	if (!accepted || name.empty()) {
+		return;
+	}
+	auto arg = QString::fromStdString(name);
+	QVariant v = QVariant::fromValue(arg);
+	QListWidgetItem *item = new QListWidgetItem(arg, _argList);
+	item->setData(Qt::UserRole, arg);
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_args << arg;
+}
+
+void MacroActionRunEdit::RemoveArg()
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	int idx = _argList->currentRow();
+	if (idx == -1) {
+		return;
+	}
+	_entryData->_args.removeAt(idx);
+
+	QListWidgetItem *item = _argList->currentItem();
+	if (!item) {
+		return;
+	}
+	delete item;
+}
+
+void MacroActionRunEdit::ArgUp()
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	int idx = _argList->currentRow();
+	if (idx != -1 && idx != 0) {
+		_argList->insertItem(idx - 1, _argList->takeItem(idx));
+		_argList->setCurrentRow(idx - 1);
+
+		std::lock_guard<std::mutex> lock(switcher->m);
+		_entryData->_args.move(idx, idx - 1);
+	}
+}
+
+void MacroActionRunEdit::ArgDown()
+{
+	int idx = _argList->currentRow();
+	if (idx != -1 && idx != _argList->count() - 1) {
+		_argList->insertItem(idx + 1, _argList->takeItem(idx));
+		_argList->setCurrentRow(idx + 1);
+
+		std::lock_guard<std::mutex> lock(switcher->m);
+		_entryData->_args.move(idx, idx + 1);
+	}
+}

src/macro-action-scene-order.cpp

@@ -0,0 +1,208 @@
+#include "headers/macro-action-scene-order.hpp"
+#include "headers/advanced-scene-switcher.hpp"
+#include "headers/utility.hpp"
+
+const std::string MacroActionSceneOrder::id = "scene_order";
+
+bool MacroActionSceneOrder::_registered = MacroActionFactory::Register(
+	MacroActionSceneOrder::id,
+	{MacroActionSceneOrder::Create, MacroActionSceneOrderEdit::Create,
+	 "AdvSceneSwitcher.action.sceneOrder"});
+
+const static std::map<SceneOrderAction, std::string> actionTypes = {
+	{SceneOrderAction::MOVE_UP,
+	 "AdvSceneSwitcher.action.sceneOrder.type.moveUp"},
+	{SceneOrderAction::MOVE_DOWN,
+	 "AdvSceneSwitcher.action.sceneOrder.type.moveDown"},
+	{SceneOrderAction::MOVE_TOP,
+	 "AdvSceneSwitcher.action.sceneOrder.type.moveTop"},
+	{SceneOrderAction::MOVE_BOTTOM,
+	 "AdvSceneSwitcher.action.sceneOrder.type.moveBottom"},
+	{SceneOrderAction::POSITION,
+	 "AdvSceneSwitcher.action.sceneOrder.type.movePosition"},
+};
+
+bool MacroActionSceneOrder::PerformAction()
+{
+	auto s = obs_weak_source_get_source(_scene.GetScene());
+	auto scene = obs_scene_from_source(s);
+	auto name = GetWeakSourceName(_source);
+	auto items = getSceneItemsWithName(scene, name);
+
+	for (auto &i : items) {
+		switch (_action) {
+		case SceneOrderAction::MOVE_UP:
+			obs_sceneitem_set_order(i, OBS_ORDER_MOVE_UP);
+			break;
+		case SceneOrderAction::MOVE_DOWN:
+			obs_sceneitem_set_order(i, OBS_ORDER_MOVE_DOWN);
+			break;
+		case SceneOrderAction::MOVE_TOP:
+			obs_sceneitem_set_order(i, OBS_ORDER_MOVE_TOP);
+			break;
+		case SceneOrderAction::MOVE_BOTTOM:
+			obs_sceneitem_set_order(i, OBS_ORDER_MOVE_BOTTOM);
+			break;
+		case SceneOrderAction::POSITION:
+			obs_sceneitem_set_order_position(i, _position);
+			break;
+		default:
+			break;
+		}
+		obs_sceneitem_release(i);
+	}
+
+	obs_source_release(s);
+	return true;
+}
+
+void MacroActionSceneOrder::LogAction()
+{
+	auto it = actionTypes.find(_action);
+	if (it != actionTypes.end()) {
+		vblog(LOG_INFO,
+		      "performed order action \"%s\" for source \"%s\" on scene \"%s\"",
+		      it->second.c_str(), GetWeakSourceName(_source).c_str(),
+		      _scene.ToString().c_str());
+	} else {
+		blog(LOG_WARNING, "ignored unknown scene order action %d",
+		     static_cast<int>(_action));
+	}
+}
+
+bool MacroActionSceneOrder::Save(obs_data_t *obj)
+{
+	MacroAction::Save(obj);
+	_scene.Save(obj);
+	obs_data_set_string(obj, "source", GetWeakSourceName(_source).c_str());
+	obs_data_set_int(obj, "action", static_cast<int>(_action));
+	obs_data_set_int(obj, "position", _position);
+	return true;
+}
+
+bool MacroActionSceneOrder::Load(obs_data_t *obj)
+{
+	MacroAction::Load(obj);
+	_scene.Load(obj);
+	const char *sourceName = obs_data_get_string(obj, "source");
+	_source = GetWeakSourceByName(sourceName);
+	_action =
+		static_cast<SceneOrderAction>(obs_data_get_int(obj, "action"));
+	_position = obs_data_get_int(obj, "position");
+	return true;
+}
+
+std::string MacroActionSceneOrder::GetShortDesc()
+{
+	if (_source) {
+		return _scene.ToString() + " - " + GetWeakSourceName(_source);
+	}
+	return "";
+}
+
+static inline void populateActionSelection(QComboBox *list)
+{
+	for (auto entry : actionTypes) {
+		list->addItem(obs_module_text(entry.second.c_str()));
+	}
+}
+
+MacroActionSceneOrderEdit::MacroActionSceneOrderEdit(
+	QWidget *parent, std::shared_ptr<MacroActionSceneOrder> entryData)
+	: QWidget(parent)
+{
+	_scenes = new SceneSelectionWidget(window(), false, false, true);
+	_sources = new QComboBox();
+	_actions = new QComboBox();
+	_position = new QSpinBox();
+
+	populateActionSelection(_actions);
+
+	QWidget::connect(_actions, SIGNAL(currentIndexChanged(int)), this,
+			 SLOT(ActionChanged(int)));
+	QWidget::connect(_scenes, SIGNAL(SceneChanged(const SceneSelection &)),
+			 this, SLOT(SceneChanged(const SceneSelection &)));
+	QWidget::connect(_sources, SIGNAL(currentTextChanged(const QString &)),
+			 this, SLOT(SourceChanged(const QString &)));
+	QWidget::connect(_position, SIGNAL(valueChanged(int)), this,
+			 SLOT(PositionChanged(int)));
+
+	QHBoxLayout *mainLayout = new QHBoxLayout;
+	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
+		{"{{scenes}}", _scenes},
+		{"{{sources}}", _sources},
+		{"{{actions}}", _actions},
+		{"{{position}}", _position},
+	};
+	placeWidgets(
+		obs_module_text("AdvSceneSwitcher.action.sceneOrder.entry"),
+		mainLayout, widgetPlaceholders);
+	setLayout(mainLayout);
+
+	_entryData = entryData;
+	UpdateEntryData();
+	_loading = false;
+}
+
+void MacroActionSceneOrderEdit::UpdateEntryData()
+{
+	if (!_entryData) {
+		return;
+	}
+
+	_actions->setCurrentIndex(static_cast<int>(_entryData->_action));
+	_scenes->SetScene(_entryData->_scene);
+	populateSceneItemSelection(_sources, _entryData->_scene);
+	_sources->setCurrentText(
+		GetWeakSourceName(_entryData->_source).c_str());
+	_position->setValue(_entryData->_position);
+	_position->setVisible(_entryData->_action ==
+			      SceneOrderAction::POSITION);
+}
+
+void MacroActionSceneOrderEdit::SceneChanged(const SceneSelection &s)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+	{
+		std::lock_guard<std::mutex> lock(switcher->m);
+		_entryData->_scene = s;
+	}
+	_sources->clear();
+	populateSceneItemSelection(_sources, _entryData->_scene);
+}
+
+void MacroActionSceneOrderEdit::SourceChanged(const QString &text)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_source = GetWeakSourceByQString(text);
+	emit HeaderInfoChanged(
+		QString::fromStdString(_entryData->GetShortDesc()));
+}
+
+void MacroActionSceneOrderEdit::ActionChanged(int value)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_action = static_cast<SceneOrderAction>(value);
+	_position->setVisible(_entryData->_action ==
+			      SceneOrderAction::POSITION);
+}
+
+void MacroActionSceneOrderEdit::PositionChanged(int value)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_position = value;
+}

src/macro-action-scene-switch.cpp

@@ -1,8 +1,8 @@
-#include "headers/macro-action-switch-scene.hpp"
+#include "headers/macro-action-scene-switch.hpp"
 #include "headers/advanced-scene-switcher.hpp"
 #include "headers/utility.hpp"
 
-const int MacroActionSwitchScene::id = 0;
+const std::string MacroActionSwitchScene::id = "scene_switch";
 
 bool MacroActionSwitchScene::_registered = MacroActionFactory::Register(
 	MacroActionSwitchScene::id,
@@ -39,6 +39,17 @@ bool MacroActionSwitchScene::Load(obs_data_t *obj)
 	return true;
 }
 
+std::string MacroActionSwitchScene::GetShortDesc()
+{
+	if (targetType == SwitchTargetType::Scene && scene) {
+		return GetWeakSourceName(scene);
+	}
+	if (targetType == SwitchTargetType::SceneGroup && group) {
+		return group->name;
+	}
+	return "";
+}
+
 MacroActionSwitchSceneEdit::MacroActionSwitchSceneEdit(
 	QWidget *parent, std::shared_ptr<MacroActionSwitchScene> entryData)
 	: SwitchWidget(parent, entryData.get(), true, true)
@@ -46,6 +57,8 @@ MacroActionSwitchSceneEdit::MacroActionSwitchSceneEdit(
 	_duration = new DurationSelection(parent, false);
 	QWidget::connect(_duration, SIGNAL(DurationChanged(double)), this,
 			 SLOT(DurationChanged(double)));
+	QWidget::connect(scenes, SIGNAL(currentTextChanged(const QString &)),
+			 this, SLOT(ChangeHeaderInfo(const QString &)));
 
 	QHBoxLayout *mainLayout = new QHBoxLayout;
 	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
@@ -71,3 +84,9 @@ void MacroActionSwitchSceneEdit::DurationChanged(double seconds)
 	std::lock_guard<std::mutex> lock(switcher->m);
 	_entryData->_duration.seconds = seconds;
 }
+
+void MacroActionSwitchSceneEdit::ChangeHeaderInfo(const QString &)
+{
+	emit HeaderInfoChanged(
+		QString::fromStdString(_entryData->GetShortDesc()));
+}

src/macro-action-scene-transform.cpp

@@ -0,0 +1,271 @@
+#include "headers/macro-action-scene-transform.hpp"
+#include "headers/advanced-scene-switcher.hpp"
+#include "headers/utility.hpp"
+
+const std::string MacroActionSceneTransform::id = "scene_transform";
+
+bool MacroActionSceneTransform::_registered = MacroActionFactory::Register(
+	MacroActionSceneTransform::id,
+	{MacroActionSceneTransform::Create,
+	 MacroActionSceneTransformEdit::Create,
+	 "AdvSceneSwitcher.action.sceneTransform"});
+
+static void load_transform_state(obs_data_t *obj,
+				 struct obs_transform_info &info,
+				 struct obs_sceneitem_crop &crop)
+{
+	obs_data_get_vec2(obj, "pos", &info.pos);
+	obs_data_get_vec2(obj, "scale", &info.scale);
+	info.rot = (float)obs_data_get_double(obj, "rot");
+	info.alignment = (uint32_t)obs_data_get_int(obj, "alignment");
+	info.bounds_type =
+		(enum obs_bounds_type)obs_data_get_int(obj, "bounds_type");
+	info.bounds_alignment =
+		(uint32_t)obs_data_get_int(obj, "bounds_alignment");
+	obs_data_get_vec2(obj, "bounds", &info.bounds);
+	crop.top = (int)obs_data_get_int(obj, "top");
+	crop.bottom = (int)obs_data_get_int(obj, "bottom");
+	crop.left = (int)obs_data_get_int(obj, "left");
+	crop.right = (int)obs_data_get_int(obj, "right");
+}
+
+bool save_transform_state(obs_data_t *obj, struct obs_transform_info &info,
+			  struct obs_sceneitem_crop &crop)
+{
+	struct vec2 pos = info.pos;
+	struct vec2 scale = info.scale;
+	float rot = info.rot;
+	uint32_t alignment = info.alignment;
+	uint32_t bounds_type = info.bounds_type;
+	uint32_t bounds_alignment = info.bounds_alignment;
+	struct vec2 bounds = info.bounds;
+
+	obs_data_set_vec2(obj, "pos", &pos);
+	obs_data_set_vec2(obj, "scale", &scale);
+	obs_data_set_double(obj, "rot", rot);
+	obs_data_set_int(obj, "alignment", alignment);
+	obs_data_set_int(obj, "bounds_type", bounds_type);
+	obs_data_set_vec2(obj, "bounds", &bounds);
+	obs_data_set_int(obj, "bounds_alignment", bounds_alignment);
+	obs_data_set_int(obj, "top", crop.top);
+	obs_data_set_int(obj, "bottom", crop.bottom);
+	obs_data_set_int(obj, "left", crop.left);
+	obs_data_set_int(obj, "right", crop.right);
+
+	return true;
+}
+
+bool MacroActionSceneTransform::PerformAction()
+{
+	auto s = obs_weak_source_get_source(_scene.GetScene(false));
+	auto scene = obs_scene_from_source(s);
+	auto name = GetWeakSourceName(_source);
+	auto items = getSceneItemsWithName(scene, name);
+
+	for (auto &item : items) {
+		// Merge new settings with current settings
+		struct obs_transform_info info;
+		struct obs_sceneitem_crop crop;
+		obs_sceneitem_get_info(item, &info);
+		obs_sceneitem_get_crop(item, &crop);
+		auto temp = obs_data_create();
+		save_transform_state(temp, info, crop);
+		auto temp2 = obs_data_create();
+		save_transform_state(temp, _info, _crop);
+		obs_data_apply(temp, temp2);
+		load_transform_state(temp, info, crop);
+		obs_data_release(temp);
+		obs_data_release(temp2);
+
+		// Apply settings
+		obs_sceneitem_defer_update_begin(item);
+		obs_sceneitem_set_info(item, &info);
+		obs_sceneitem_set_crop(item, &crop);
+		obs_sceneitem_defer_update_end(item);
+
+		obs_sceneitem_release(item);
+	}
+
+	obs_source_release(s);
+	return true;
+}
+
+void MacroActionSceneTransform::LogAction()
+{
+	vblog(LOG_INFO,
+	      "performed transform action for source \"%s\" on scene \"%s\"",
+	      GetWeakSourceName(_source).c_str(), _scene.ToString().c_str());
+}
+
+bool MacroActionSceneTransform::Save(obs_data_t *obj)
+{
+	MacroAction::Save(obj);
+	_scene.Save(obj);
+	obs_data_set_string(obj, "source", GetWeakSourceName(_source).c_str());
+	save_transform_state(obj, _info, _crop);
+	return true;
+}
+
+bool MacroActionSceneTransform::Load(obs_data_t *obj)
+{
+	MacroAction::Load(obj);
+	_scene.Load(obj);
+	const char *sourceName = obs_data_get_string(obj, "source");
+	_source = GetWeakSourceByName(sourceName);
+	load_transform_state(obj, _info, _crop);
+	return true;
+}
+
+std::string MacroActionSceneTransform::GetShortDesc()
+{
+	if (_source) {
+		return _scene.ToString() + " - " + GetWeakSourceName(_source);
+	}
+	return "";
+}
+
+std::string MacroActionSceneTransform::GetSettings()
+{
+	auto data = obs_data_create();
+	save_transform_state(data, _info, _crop);
+	std::string json = obs_data_get_json(data);
+	obs_data_release(data);
+	return json;
+}
+
+void MacroActionSceneTransform::SetSettings(std::string &settings)
+{
+	auto data = obs_data_create_from_json(settings.c_str());
+	if (!data) {
+		return;
+	}
+	load_transform_state(data, _info, _crop);
+	obs_data_release(data);
+}
+
+MacroActionSceneTransformEdit::MacroActionSceneTransformEdit(
+	QWidget *parent, std::shared_ptr<MacroActionSceneTransform> entryData)
+	: QWidget(parent)
+{
+	_scenes = new SceneSelectionWidget(window(), false, false, true);
+	_sources = new QComboBox();
+	_getSettings = new QPushButton(obs_module_text(
+		"AdvSceneSwitcher.action.sceneTransform.getTransform"));
+	_settings = new QPlainTextEdit();
+
+	QWidget::connect(_scenes, SIGNAL(SceneChanged(const SceneSelection &)),
+			 this, SLOT(SceneChanged(const SceneSelection &)));
+	QWidget::connect(_sources, SIGNAL(currentTextChanged(const QString &)),
+			 this, SLOT(SourceChanged(const QString &)));
+	QWidget::connect(_getSettings, SIGNAL(clicked()), this,
+			 SLOT(GetSettingsClicked()));
+	QWidget::connect(_settings, SIGNAL(textChanged()), this,
+			 SLOT(SettingsChanged()));
+
+	QHBoxLayout *entryLayout = new QHBoxLayout;
+
+	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
+		{"{{scenes}}", _scenes},
+		{"{{sources}}", _sources},
+		{"{{settings}}", _settings},
+		{"{{getSettings}}", _getSettings},
+	};
+	placeWidgets(
+		obs_module_text("AdvSceneSwitcher.action.sceneTransform.entry"),
+		entryLayout, widgetPlaceholders);
+
+	QHBoxLayout *buttonLayout = new QHBoxLayout;
+	buttonLayout->addWidget(_getSettings);
+	buttonLayout->addStretch();
+
+	QVBoxLayout *mainLayout = new QVBoxLayout;
+	mainLayout->addLayout(entryLayout);
+	mainLayout->addWidget(_settings);
+	mainLayout->addLayout(buttonLayout);
+	setLayout(mainLayout);
+
+	_entryData = entryData;
+	UpdateEntryData();
+	_loading = false;
+}
+
+void MacroActionSceneTransformEdit::UpdateEntryData()
+{
+	if (!_entryData) {
+		return;
+	}
+
+	_scenes->SetScene(_entryData->_scene);
+	populateSceneItemSelection(_sources, _entryData->_scene);
+	_sources->setCurrentText(
+		GetWeakSourceName(_entryData->_source).c_str());
+	if (_entryData->_source) {
+		_settings->setPlainText(
+			formatJsonString(_entryData->GetSettings()));
+	}
+}
+
+void MacroActionSceneTransformEdit::SceneChanged(const SceneSelection &s)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+	{
+		std::lock_guard<std::mutex> lock(switcher->m);
+		_entryData->_scene = s;
+	}
+	_sources->clear();
+	populateSceneItemSelection(_sources, _entryData->_scene);
+}
+
+void MacroActionSceneTransformEdit::SourceChanged(const QString &text)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_source = GetWeakSourceByQString(text);
+	emit HeaderInfoChanged(
+		QString::fromStdString(_entryData->GetShortDesc()));
+}
+
+void MacroActionSceneTransformEdit::GetSettingsClicked()
+{
+	if (_loading || !_entryData || !_entryData->_scene.GetScene(false) ||
+	    !_entryData->_source) {
+		return;
+	}
+
+	auto s = obs_weak_source_get_source(_entryData->_scene.GetScene(false));
+	auto scene = obs_scene_from_source(s);
+	auto name = GetWeakSourceName(_entryData->_source);
+	auto item = obs_scene_find_source_recursive(scene, name.c_str());
+	obs_source_release(s);
+
+	if (!item) {
+		return;
+	}
+
+	struct obs_transform_info info;
+	struct obs_sceneitem_crop crop;
+	obs_sceneitem_get_info(item, &info);
+	obs_sceneitem_get_crop(item, &crop);
+
+	auto data = obs_data_create();
+	save_transform_state(data, info, crop);
+	auto json = obs_data_get_json(data);
+	_settings->setPlainText(formatJsonString(json));
+	obs_data_release(data);
+}
+
+void MacroActionSceneTransformEdit::SettingsChanged()
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	auto json = _settings->toPlainText().toStdString();
+	_entryData->SetSettings(json);
+}