Update locale of "cooldown" and "no match" behaviour

New users will be confused if their macros are not executed,
if they are "blocked" by other scene switching methods.

CI/release/README.txt

@@ -19,7 +19,14 @@ Optional:
  * libXtst
  * libcurl
 
-Copy the advanced-scene-switcher.so file and into the OBS Studio plugin folder.
+If you are using snap you can install the following package for an OBS installation which comes bundled with the plugin:
+sudo snap install obs-studio
+
+The plugin is also available via the Flatpak package manager for users who installed OBS via Flatpak:
+flatpak install com.obsproject.Studio.Plugin.SceneSwitcher
+
+If you have installed OBS via other means, it is most likely necessary to install the plugin manually.
+To do so copy the advanced-scene-switcher.so file and into the OBS Studio plugin folder.
 The location of this folder can vary, so you might have to look around a bit.
 
 Examples are ...
@@ -30,13 +37,39 @@ Examples are ...
 ~/.local/share/flatpak/app/com.obsproject.Studio/x86_64/stable/active/files/lib/obs-plugins/
 /var/lib/flatpak/app/com.obsproject.Studio/x86_64/stable/active/files/lib/obs-plugins/
 
-Unfortunately the expected location of the locale, which can be found in the data folder, can vary also.
-The data folder usually should be copied to:
-~/.config/obs-studio/plugins/advanced-scene-switcher/
+Unfortunately the expected location of the "locale" and "res" folder, which can be found in the data folder, can vary also.
+The data folder usually should be copied to "~/.config/obs-studio/plugins/advanced-scene-switcher/" and reflect the following structure:
+
+/home/user/.config/obs-studio/plugins/
+└── advanced-scene-switcher
+    ├── bin
+    │   └── 64bit
+    │       └── advanced-scene-switcher.so
+    └── data
+        ├── locale
+        │   ├── de-DE.ini
+        │   ├── en-US.ini
+        │   ├── ru-RU.ini
+        │   └── zh-CN.ini
+        └── res
+            ├── cascadeClassifiers
+            │   ├── haarcascade_eye_tree_eyeglasses.xml
+            │   ├── haarcascade_eye.xml
+            │   ├── haarcascade_frontalface_alt2.xml
+            │   ├── haarcascade_frontalface_alt_tree.xml
+            │   ├── haarcascade_frontalface_alt.xml
+            │   ├── haarcascade_frontalface_default.xml
+            │   ├── haarcascade_fullbody.xml
+            │   ├── haarcascade_lefteye_2splits.xml
+            │   ├── haarcascade_lowerbody.xml
+            │   ├── haarcascade_profileface.xml
+            │   ├── haarcascade_righteye_2splits.xml
+            │   └── haarcascade_upperbody.xml
+            └── time.svg
 
 If this does not work you can try to copy the "locale" folder found inside the data folder to:
 /usr/share/obs/obs-plugins/advanced-scene-switcher/locale
 ~/.local/share/flatpak/app/com.obsproject.Studio/x86_64/stable/active/files/share/obs/obs-plugins/advanced-scene-switcher/locale
 /var/lib/flatpak/app/com.obsproject.Studio/x86_64/stable/active/files/share/obs/obs-plugins/advanced-scene-switcher/locale
 
-In doubt please check where other "en-US.ini" files are located on your system.
+In doubt, please check where other "en-US.ini" files are located on your system.

CMakeLists.txt

@@ -101,24 +101,6 @@ if(BUILD_OUT_OF_TREE)
 
   find_package(CURL REQUIRED)
   include_directories("${CURL_INCLUDE_DIRS}")
-
-  # Backwards compatability with older OBS versions
-  if(LibObs_VERSION_MAJOR GREATER_EQUAL 27)
-    add_definitions(-DVCAM_SUPPORTED)
-  else()
-    message(
-      WARNING
-        "OBS version ${LibObs_VERSION_MAJOR} found - disabling virtual camera functionality"
-    )
-  endif()
-  if(LibObs_VERSION_MAJOR GREATER_EQUAL 26)
-    add_definitions(-DREPLAYBUFFER_SUPPORTED)
-  else()
-    message(
-      WARNING
-        "OBS version ${LibObs_VERSION_MAJOR} found - disabling replay buffer functionality"
-    )
-  endif()
 else()
   find_package(Libcurl REQUIRED)
   include_directories("${LIBCURL_INCLUDE_DIRS}")
@@ -224,8 +206,10 @@ set(advanced-scene-switcher_HEADERS
     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-screenshot.hpp
     src/headers/macro-action-source.hpp
     src/headers/macro-action-streaming.hpp
+    src/headers/macro-action-systray.hpp
     src/headers/macro-action-timer.hpp
     src/headers/macro-action-transition.hpp
     src/headers/macro-action-virtual-cam.hpp
@@ -317,8 +301,10 @@ set(advanced-scene-switcher_SOURCES
     src/macro-action-scene-switch.cpp
     src/macro-action-scene-transform.cpp
     src/macro-action-scene-visibility.cpp
+    src/macro-action-screenshot.cpp
     src/macro-action-source.cpp
     src/macro-action-streaming.cpp
+    src/macro-action-systray.cpp
     src/macro-action-timer.cpp
     src/macro-action-transition.cpp
     src/macro-action-virtual-cam.cpp
@@ -380,6 +366,30 @@ else()
        src/headers/macro-condition-video.hpp)
 endif()
 
+# Backwards compatability checks with older OBS versions
+if(DEFINED LibObs_VERSION_MAJOR)
+  if(LibObs_VERSION_MAJOR GREATER_EQUAL 27)
+    add_definitions(-DVCAM_SUPPORTED)
+  else()
+    message(
+      WARNING
+        "OBS version ${LibObs_VERSION_MAJOR} found - disabling virtual camera functionality"
+    )
+  endif()
+  if(LibObs_VERSION_MAJOR GREATER_EQUAL 26)
+    add_definitions(-DREPLAYBUFFER_SUPPORTED)
+  else()
+    message(
+      WARNING
+        "OBS version ${LibObs_VERSION_MAJOR} found - disabling replay buffer and screenshot functionality"
+    )
+    list(REMOVE_ITEM advanced-scene-switcher_SOURCES
+         src/macro-action-screenshot.cpp)
+    list(REMOVE_ITEM advanced-scene-switcher_HEADERS
+         src/headers/macro-action-screenshot.hpp)
+  endif()
+endif()
+
 add_library(
   advanced-scene-switcher MODULE
   ${advanced-scene-switcher_HEADERS}

README.md

@@ -15,6 +15,10 @@ For Linux the Snap package manager offers an OBS Studio installation which is bu
 ```
 sudo snap install obs-studio
 ```
+The plugin is also available via the Flatpak package manager for users who installed OBS via Flatpak:
+```
+flatpak install com.obsproject.Studio.Plugin.SceneSwitcher
+```
 
 If that is not an option you will have to ... 
 1. Copy the library to the plugins folder of you obs installation.

data/locale/en-US.ini

@@ -19,12 +19,12 @@ AdvSceneSwitcher.generalTab.status.autoStart.streaming="Streaming"
 AdvSceneSwitcher.generalTab.status.autoStart.recordingAndStreaming="Recording or Streaming"
 AdvSceneSwitcher.generalTab.status.checkInterval="Check switch conditions every"
 AdvSceneSwitcher.generalTab.generalBehavior="General behavior"
-AdvSceneSwitcher.generalTab.generalBehavior.onNoMet="If no switch condition is met for"
+AdvSceneSwitcher.generalTab.generalBehavior.onNoMet="If no actions are performed for"
 AdvSceneSwitcher.generalTab.generalBehavior.onNoMetDelayTooltip="Will only ever be as accurate as the configured check interval."
 AdvSceneSwitcher.generalTab.generalBehavior.onNoMet.dontSwitch="Don't switch"
 AdvSceneSwitcher.generalTab.generalBehavior.onNoMet.switchToRandom="Switch to any scene in Random tab"
 AdvSceneSwitcher.generalTab.generalBehavior.onNoMet.switchTo="Switch to:"
-AdvSceneSwitcher.generalTab.generalBehavior.cooldown="After a match do not switch scenes for"
+AdvSceneSwitcher.generalTab.generalBehavior.cooldown="After a match don't perform actions for"
 AdvSceneSwitcher.generalTab.generalBehavior.cooldownHint="During this time potential matches will be ignored!"
 AdvSceneSwitcher.generalTab.generalBehavior.verboseLogging="Enable verbose logging"
 AdvSceneSwitcher.generalTab.generalBehavior.saveWindowGeo="Save window position and size"
@@ -57,6 +57,7 @@ AdvSceneSwitcher.generalTab.priority.macro="Macro"
 ; Macro Tab
 AdvSceneSwitcher.macroTab.title="Macro"
 AdvSceneSwitcher.macroTab.macros="Macros"
+AdvSceneSwitcher.macroTab.priorityWarning="Note: It is recommended to configure macros to be the highest priority functionality.\nThis setting can be changed on the General tab."
 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.\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."
@@ -66,6 +67,9 @@ AdvSceneSwitcher.macroTab.edit.condition="Condition type:"
 AdvSceneSwitcher.macroTab.edit.action="Action type:"
 AdvSceneSwitcher.macroTab.add="Add new macro"
 AdvSceneSwitcher.macroTab.name="Name:"
+AdvSceneSwitcher.macroTab.run="Run macro"
+AdvSceneSwitcher.macroTab.runFail="Running \"%1\" failed!\nEither one of the actions failed or the macro is running already."
+AdvSceneSwitcher.macroTab.runInParallel="Run macro in parallel to other macros"
 AdvSceneSwitcher.macroTab.defaultname="Macro %1"
 AdvSceneSwitcher.macroTab.exists="Macro name exists already"
 AdvSceneSwitcher.macroTab.copy="Create copy"
@@ -108,7 +112,10 @@ AdvSceneSwitcher.condition.file.entry.line1="Content of {{fileType}} {{filePath}
 AdvSceneSwitcher.condition.file.entry.line2="{{matchText}}"
 AdvSceneSwitcher.condition.file.entry.line3="{{useRegex}} {{checkModificationDate}} {{checkFileContent}}"
 AdvSceneSwitcher.condition.media="Media"
-AdvSceneSwitcher.condition.media.entry="{{mediaSources}} state is {{states}} and {{timeRestrictions}} {{time}}"
+AdvSceneSwitcher.condition.media.anyOnScene="Any media source on"
+AdvSceneSwitcher.condition.media.allOnScene="All media sources on"
+AdvSceneSwitcher.condition.media.matchOnChange="Only match on change (Note: This option will be removed in a future version - please use time constraints instead)"
+AdvSceneSwitcher.condition.media.entry="{{mediaSources}}{{scenes}} state is {{states}} and {{timeRestrictions}} {{time}}"
 AdvSceneSwitcher.condition.video="Video"
 AdvSceneSwitcher.condition.video.condition.match="exactly matches"
 AdvSceneSwitcher.condition.video.condition.differ="does not match"
@@ -156,11 +163,15 @@ AdvSceneSwitcher.condition.idle="Idle"
 AdvSceneSwitcher.condition.idle.entry="No keyboard or mouse inputs for {{duration}}"
 AdvSceneSwitcher.condition.pluginState="Plugin state"
 AdvSceneSwitcher.condition.pluginState.state.sceneSwitched="Automated scene change was triggered in this interval"
+AdvSceneSwitcher.condition.pluginState.state.running="Advanced scene switcher is running"
 AdvSceneSwitcher.condition.pluginState.entry="{{condition}}"
 AdvSceneSwitcher.condition.timer="Timer"
+AdvSceneSwitcher.condition.timer.type.fixed="Fixed"
+AdvSceneSwitcher.condition.timer.type.random="Random"
 AdvSceneSwitcher.condition.timer.pause="Pause"
 AdvSceneSwitcher.condition.timer.continue="Continue"
-AdvSceneSwitcher.condition.timer.entry.line1="{{duration}} have passed"
+AdvSceneSwitcher.condition.timer.entry.line1.fixed="{{type}} duration of {{duration}} has passed"
+AdvSceneSwitcher.condition.timer.entry.line1.random="{{type}} duration from {{duration}} to {{duration2}} has passed"
 AdvSceneSwitcher.condition.timer.entry.line2="Time remaining: {{remaining}} seconds"
 AdvSceneSwitcher.condition.timer.entry.line3="{{pauseContinue}} {{reset}} {{saveRemaining}} Save time remaining {{autoReset}} Automatically reset timer after duration was reached"
 AdvSceneSwitcher.condition.timer.reset="Reset"
@@ -229,10 +240,12 @@ AdvSceneSwitcher.condition.sceneTransform.entry.line3="{{regex}} {{getSettings}}
 AdvSceneSwitcher.condition.transition="Transition"
 AdvSceneSwitcher.condition.transition.type.current="Current transition type is"
 AdvSceneSwitcher.condition.transition.type.duration="Current transition duration is"
-AdvSceneSwitcher.condition.transition.type.started="Transition active"
+AdvSceneSwitcher.condition.transition.type.started="Transition started"
 AdvSceneSwitcher.condition.transition.type.ended="Transition ended"
+AdvSceneSwitcher.condition.transition.type.transitionSource="Transitioning from"
+AdvSceneSwitcher.condition.transition.type.transitionTarget="Transitioning to"
 AdvSceneSwitcher.condition.transition.durationSuffix="seconds"
-AdvSceneSwitcher.condition.transition.entry="{{conditions}}{{transitions}}{{duration}}{{durationSuffix}}"
+AdvSceneSwitcher.condition.transition.entry="{{conditions}}{{transitions}}{{scenes}}{{duration}}{{durationSuffix}}"
 AdvSceneSwitcher.condition.sceneVisibility="Scene item visibility"
 AdvSceneSwitcher.condition.sceneVisibility.type.shown="Shown"
 AdvSceneSwitcher.condition.sceneVisibility.type.hidden="Hidden"
@@ -305,6 +318,7 @@ 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.type.run="Run"
 AdvSceneSwitcher.action.macro.entry="{{actions}} {{macros}}"
 AdvSceneSwitcher.action.pluginState="Plugin state"
 AdvSceneSwitcher.action.pluginState.type.stop="Stop the Advanced Scene Switcher plugin"
@@ -354,9 +368,12 @@ AdvSceneSwitcher.action.timer.type.reset="Reset"
 AdvSceneSwitcher.action.timer.type.setTimeRemaining="Set time remaining of"
 AdvSceneSwitcher.action.timer.entry="{{timerAction}} timers on {{macros}} {{duration}}"
 AdvSceneSwitcher.action.random="Random"
-AdvSceneSwitcher.action.random.arguments="Macros:"
-AdvSceneSwitcher.action.random.addArgument="Add Macro"
-AdvSceneSwitcher.action.random.entry="Run {{macroSelection}}"
+AdvSceneSwitcher.action.random.entry="Randomly run any of the following macros (paused macros are ignored)"
+AdvSceneSwitcher.action.systray="System tray notification"
+AdvSceneSwitcher.action.systray.entry="Show notification: {{message}}"
+AdvSceneSwitcher.action.screenshot="Screenshot"
+AdvSceneSwitcher.action.screenshot.mainOutput="OBS's main output"
+AdvSceneSwitcher.action.screenshot.entry="Screenshot {{sources}}"
 
 ; Transition Tab
 AdvSceneSwitcher.transitionTab.title="Transition"
@@ -602,8 +619,10 @@ 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.hotkey.macro.togglePause="Toggle pause of macro %1"
 
 AdvSceneSwitcher.askBackup="Detected a new version of the Advanced Scene Switcher.\nShould a backup of the old settings be created?"
+AdvSceneSwitcher.askForMacro="Select macro {{macroSelection}}"
 
 AdvSceneSwitcher.close="Close"
 AdvSceneSwitcher.browse="Browse"

data/locale/zh-CN.ini

@@ -12,17 +12,23 @@ 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="全局行为"
 AdvSceneSwitcher.generalTab.generalBehavior.onNoMet="如果不符合任何切换条件"
 AdvSceneSwitcher.generalTab.generalBehavior.onNoMetDelayTooltip="时间精度最高只能达到配置的轮询间隔"
 AdvSceneSwitcher.generalTab.generalBehavior.onNoMet.dontSwitch="不切换"
 AdvSceneSwitcher.generalTab.generalBehavior.onNoMet.switchToRandom="切换到随机场景列表中任意随机场景"
 AdvSceneSwitcher.generalTab.generalBehavior.onNoMet.switchTo="切换到"
+AdvSceneSwitcher.generalTab.generalBehavior.cooldown="比赛结束多少秒后切换场景"
+AdvSceneSwitcher.generalTab.generalBehavior.cooldownHint="在此期间，可能的匹配项将被忽略!"
 AdvSceneSwitcher.generalTab.generalBehavior.verboseLogging="详细日志输出"
+AdvSceneSwitcher.generalTab.generalBehavior.saveWindowGeo="保存窗口位置和大小"
+AdvSceneSwitcher.generalTab.generalBehavior.showTrayNotifications="显示系统托盘通知"
 AdvSceneSwitcher.generalTab.generalBehavior.disableUIHints="禁用UI提示"
 AdvSceneSwitcher.generalTab.priority="优先级"
 AdvSceneSwitcher.generalTab.priority.description="切换场景优先级 (最上方的项优先级最高)"
@@ -45,22 +51,338 @@ 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在左侧选择现有宏或添加新宏。\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="创建副本"
+AdvSceneSwitcher.macroTab.expandAll="全部展开"
+AdvSceneSwitcher.macroTab.collapseAll="全部收回"
+
+; 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.condition.audio.state.below="小于"
+AdvSceneSwitcher.condition.audio.state.above="大于"
+AdvSceneSwitcher.condition.audio.entry="音量 来源 {{audioSources}} 是 {{condition}} {{volume}}"
+AdvSceneSwitcher.condition.cursor="光标"
+AdvSceneSwitcher.condition.cursor.type.region="当前位置"
+AdvSceneSwitcher.condition.cursor.type.moving="正在移动"
+AdvSceneSwitcher.condition.cursor.showFrame="显示帧率"
+AdvSceneSwitcher.condition.cursor.hideFrame="隐藏帧率"
+AdvSceneSwitcher.condition.cursor.entry.line1="光标 处于{{conditions}} {{minX}} {{minY}} {{maxX}} {{maxY}} - {{toggleFrameButton}}"
+AdvSceneSwitcher.condition.cursor.entry.line2="光标当前位于 {{xPos}} x {{yPos}}"
+AdvSceneSwitcher.condition.scene="场景"
+AdvSceneSwitcher.condition.scene.type.current="当前场景是"
+AdvSceneSwitcher.condition.scene.type.previous="上一个场景是"
+AdvSceneSwitcher.condition.scene.type.changed="场景改变了"
+AdvSceneSwitcher.condition.scene.type.notChanged="场景没有改变"
+AdvSceneSwitcher.condition.scene.waitForTransition="等待过渡完成"
+AdvSceneSwitcher.condition.scene.entry="{{sceneType}} {{scenes}} {{waitForTransition}}"
+AdvSceneSwitcher.condition.window="窗口"
+AdvSceneSwitcher.condition.window.entry.line1="{{windows}} 存在..."
+AdvSceneSwitcher.condition.window.entry.line2="... 并且是 {{fullscreen}} 全屏 {{maximized}} 最大化 {{focused}} 获得焦点 {{windowFocusChanged}} 焦点窗口已更改"
+AdvSceneSwitcher.condition.file="文件"
+AdvSceneSwitcher.condition.file.entry.line1="内容 {{fileType}} {{filePath}} (本地是文本，网络是获取的网页)完全匹配:"
+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.condition.pattern="匹配模式"
+AdvSceneSwitcher.condition.video.condition.object="包含对象"
+AdvSceneSwitcher.condition.video.askFileAction="是否要使用现有文件或创建当前选定源的屏幕截图？"
+AdvSceneSwitcher.condition.video.askFileAction.file="使用现有文件"
+AdvSceneSwitcher.condition.video.askFileAction.screenshot="创建屏幕截图"
+AdvSceneSwitcher.condition.video.usePatternForChangedCheck="使用模式匹配"
+AdvSceneSwitcher.condition.video.usePatternForChangedCheck.tooltip="这将允许您控制图像必须更改多少才能使条件为真."
+AdvSceneSwitcher.condition.video.patternThreshold="阈值: "
+AdvSceneSwitcher.condition.video.patternThresholdDescription="较高的阈值意味着模式需要更紧密地匹配视频源."
+AdvSceneSwitcher.condition.video.patternThresholdUseAlphaAsMask="使用alpha通道作为图案的遮罩."
+AdvSceneSwitcher.condition.video.objectScaleThreshold="模型比例: "
+AdvSceneSwitcher.condition.video.objectScaleThresholdDescription="较低的模比例将导致更多的匹配，但会导致更高的CPU负载."
+AdvSceneSwitcher.condition.video.minNeighborDescription="较高的“最小区域”值将导致较少但质量较高的匹配."
+AdvSceneSwitcher.condition.video.showMatch="显示模式"
+AdvSceneSwitcher.condition.video.screenshotFail="无法获取源的屏幕截图!"
+AdvSceneSwitcher.condition.video.patternMatchFail="没有找到模式!"
+AdvSceneSwitcher.condition.video.objectMatchFail="找不到对象!"
+AdvSceneSwitcher.condition.video.modelLoadFail="无法加载模型数据!"
+AdvSceneSwitcher.condition.video.entry="{{videoSources}} {{condition}} {{imagePath}}"
+AdvSceneSwitcher.condition.video.entry.modelPath="模型数据 (haar级联分类器): {{modelDataPath}}"
+AdvSceneSwitcher.condition.video.entry.minNeighbor="最小区域: {{minNeighbors}}"
+AdvSceneSwitcher.condition.video.entry.minSize="最小尺寸: {{minSizeX}} x {{minSizeY}}"
+AdvSceneSwitcher.condition.video.entry.maxSize="最大尺寸: {{maxSizeX}} x {{maxSizeY}}"
+AdvSceneSwitcher.condition.video.entry.throttle="{{throttleEnable}}通过只执行每一次检查来减少CPU负载 {{throttleCount}} 毫秒"
+AdvSceneSwitcher.condition.stream="推流"
+AdvSceneSwitcher.condition.stream.state.start="推流启动"
+AdvSceneSwitcher.condition.stream.state.stop="推流停止"
+AdvSceneSwitcher.condition.stream.state.starting="推流启动中"
+AdvSceneSwitcher.condition.stream.state.stopping="推流停止中"
+AdvSceneSwitcher.condition.stream.entry="{{streamState}}"
+AdvSceneSwitcher.condition.record="录制"
+AdvSceneSwitcher.condition.record.state.start="录制运行中"
+AdvSceneSwitcher.condition.record.state.pause="录制暂停"
+AdvSceneSwitcher.condition.record.state.stop="录制停止"
+AdvSceneSwitcher.condition.record.entry="{{recordState}}"
+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}}"
+AdvSceneSwitcher.condition.timer="计时器"
+AdvSceneSwitcher.condition.timer.pause="暂停"
+AdvSceneSwitcher.condition.timer.continue="继续"
+AdvSceneSwitcher.condition.timer.entry.line1="{{duration}} 时间倒计时"
+AdvSceneSwitcher.condition.timer.entry.line2="剩余时间: {{remaining}} 秒"
+AdvSceneSwitcher.condition.timer.entry.line3="{{pauseContinue}} {{reset}} {{saveRemaining}} 保存剩余时间 {{autoReset}} 达到时间后自动重置计时器"
+AdvSceneSwitcher.condition.timer.reset="重置"
+AdvSceneSwitcher.condition.macro="宏"
+AdvSceneSwitcher.condition.macro.type.count="计数"
+AdvSceneSwitcher.condition.macro.type.state="状态"
+AdvSceneSwitcher.condition.macro.type.selection="条件类型: {{types}}"
+AdvSceneSwitcher.condition.macro.count.type.below="少于"
+AdvSceneSwitcher.condition.macro.count.type.above="大于"
+AdvSceneSwitcher.condition.macro.count.type.equal="等于"
+AdvSceneSwitcher.condition.macro.count.reset="重置"
+AdvSceneSwitcher.condition.macro.pausedWarning="所选宏当前已暂停!"
+AdvSceneSwitcher.condition.macro.state.entry="条件 {{macros}} 是真的"
+AdvSceneSwitcher.condition.macro.count.entry.line1="{{macros}} 运行 {{conditions}} {{count}} 次（相对于下面计数匹配）"
+AdvSceneSwitcher.condition.macro.count.entry.line2="当前计数: {{currentCount}} {{resetCount}}"
+AdvSceneSwitcher.condition.source="源"
+AdvSceneSwitcher.condition.source.type.active="激活状态"
+AdvSceneSwitcher.condition.source.type.showing="显示状态"
+AdvSceneSwitcher.condition.source.type.settings="设置完全匹配"
+AdvSceneSwitcher.condition.source.regex="使用正则表达式"
+AdvSceneSwitcher.condition.source.getSettings="获取当前设置"
+AdvSceneSwitcher.condition.source.entry.line1="{{sources}} {{conditions}}"
+AdvSceneSwitcher.condition.source.entry.line2="{{settings}}"
+AdvSceneSwitcher.condition.source.entry.line3="{{regex}} {{getSettings}}"
+AdvSceneSwitcher.condition.virtualCamera="虚拟摄像机"
+AdvSceneSwitcher.condition.virtualCamera.state.start="虚拟摄像机启动"
+AdvSceneSwitcher.condition.virtualCamera.state.stop="虚拟摄像机停止"
+AdvSceneSwitcher.condition.virtualCamera.entry="{{states}}"
+AdvSceneSwitcher.condition.filter="滤镜"
+AdvSceneSwitcher.condition.filter.type.active="已启用"
+AdvSceneSwitcher.condition.filter.type.showing="已关闭"
+AdvSceneSwitcher.condition.filter.type.settings="设置完全匹配"
+AdvSceneSwitcher.condition.filter.regex="使用正则表达式"
+AdvSceneSwitcher.condition.filter.getSettings="获取当前设置"
+AdvSceneSwitcher.condition.filter.entry.line1="在 {{sources}} {{filters}} {{conditions}}"
+AdvSceneSwitcher.condition.filter.entry.line2="{{settings}}"
+AdvSceneSwitcher.condition.filter.entry.line3="{{regex}} {{getSettings}}"
+AdvSceneSwitcher.condition.sceneOrder="场景项目顺序"
+AdvSceneSwitcher.condition.sceneOrder.type.above="高于"
+AdvSceneSwitcher.condition.sceneOrder.type.below="低于"
+AdvSceneSwitcher.condition.sceneOrder.type.position="位置值排比"
+AdvSceneSwitcher.condition.sceneOrder.positionInfo="位置值从底部以0开始，对于每个场景项目（包括场景组中的项目）增加1，自行测试，按照上下往上排比数值。"
+AdvSceneSwitcher.condition.sceneOrder.entry="在 {{scenes}} {{sources}} {{conditions}} {{sources2}} {{position}}"
+AdvSceneSwitcher.condition.hotkey="热键"
+AdvSceneSwitcher.condition.hotkey.name="宏触发热键"
+AdvSceneSwitcher.condition.hotkey.tip="注意：您可以在OBS设置窗口中为此热键配置按键绑定"
+AdvSceneSwitcher.condition.hotkey.entry="名称: {{name}}"
+AdvSceneSwitcher.condition.replay="回放缓存"
+AdvSceneSwitcher.condition.replay.state.stopped="回放缓存已停止"
+AdvSceneSwitcher.condition.replay.state.started="回放缓存已启动"
+AdvSceneSwitcher.condition.replay.state.saved="已保存回放缓存"
+AdvSceneSwitcher.condition.replay.entry="{{state}}"
+AdvSceneSwitcher.condition.date="日期"
+AdvSceneSwitcher.condition.date.state.at="现在"
+AdvSceneSwitcher.condition.date.state.after="之后"
+AdvSceneSwitcher.condition.date.state.before="之前"
+AdvSceneSwitcher.condition.date.state.between="之间"
+AdvSceneSwitcher.condition.date.entry.line1="{{condition}} {{dateTime}} {{dateTime2}} {{ignoreDate}} 忽略日期 {{ignoreTime}} 忽略时间"
+AdvSceneSwitcher.condition.date.entry.line2="{{repeat}} 重复的每一次 {{duration}} 匹配的时间"
+AdvSceneSwitcher.condition.sceneTransform="场景项目被改变"
+AdvSceneSwitcher.condition.sceneTransform.getTransform="内容或者设置被改变了"
+AdvSceneSwitcher.condition.sceneTransform.regex="使用正则表达式"
+AdvSceneSwitcher.condition.sceneTransform.entry.line1="在 {{scenes}} {{sources}} 匹配变换"
+AdvSceneSwitcher.condition.sceneTransform.entry.line2="{{settings}}"
+AdvSceneSwitcher.condition.sceneTransform.entry.line3="{{regex}} {{getSettings}}"
+AdvSceneSwitcher.condition.transition="转场"
+AdvSceneSwitcher.condition.transition.type.current="当前转场特效类型为"
+AdvSceneSwitcher.condition.transition.type.duration="当前转场特效持续时间为"
+AdvSceneSwitcher.condition.transition.type.started="转场特效开始"
+AdvSceneSwitcher.condition.transition.type.ended="转场特效结束"
+AdvSceneSwitcher.condition.transition.durationSuffix="秒"
+AdvSceneSwitcher.condition.transition.entry="{{conditions}}{{transitions}}{{duration}}{{durationSuffix}}"
+AdvSceneSwitcher.condition.sceneVisibility="场景项目可见"
+AdvSceneSwitcher.condition.sceneVisibility.type.shown="显示的"
+AdvSceneSwitcher.condition.sceneVisibility.type.hidden="隐藏的"
+AdvSceneSwitcher.condition.sceneVisibility.entry="在 {{scenes}} {{sources}} 是 {{conditions}} "
+
+; 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.fade="{{fade}}淡出 {{duration}} 秒"
+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.arguments="参数:"
+AdvSceneSwitcher.action.run.addArgument="添加参数"
+AdvSceneSwitcher.action.run.addArgumentDescription="添加新参数:"
+AdvSceneSwitcher.action.run.entry="运行 {{filePath}}"
+AdvSceneSwitcher.action.sceneVisibility="场景项目可见性"
+AdvSceneSwitcher.action.sceneVisibility.type.show="显示"
+AdvSceneSwitcher.action.sceneVisibility.type.hide="隐藏"
+AdvSceneSwitcher.action.sceneVisibility.type.source="来源"
+AdvSceneSwitcher.action.sceneVisibility.type.sourceGroup="全部"
+AdvSceneSwitcher.action.sceneVisibility.entry="在 {{scenes}} {{actions}} {{sourceTypes}} {{sources}}"
+AdvSceneSwitcher.action.filter="滤镜"
+AdvSceneSwitcher.action.filter.type.enable="开启"
+AdvSceneSwitcher.action.filter.type.disable="关闭"
+AdvSceneSwitcher.action.filter.type.settings="参数设置"
+AdvSceneSwitcher.action.filter.entry="在 {{sources}} {{actions}} {{filters}}"
+AdvSceneSwitcher.action.filter.getSettings="获取当前设置"
+AdvSceneSwitcher.action.source="来源"
+AdvSceneSwitcher.action.source.type.enable="启用"
+AdvSceneSwitcher.action.source.type.disable="停用"
+AdvSceneSwitcher.action.source.type.settings="配置设置"
+AdvSceneSwitcher.action.source.entry="{{actions}} {{sources}}"
+AdvSceneSwitcher.action.source.warning="警告：OBS UI无法控制全局启用和禁用源，注意，通过这个设置禁用，我测试，你必须通过这个在启用才行，不然点击小眼睛你无法显示！"
+AdvSceneSwitcher.action.source.getSettings="获取当前设置"
+AdvSceneSwitcher.action.media="媒体"
+AdvSceneSwitcher.action.media.type.play="开始"
+AdvSceneSwitcher.action.media.type.pause="暂停"
+AdvSceneSwitcher.action.media.type.stop="停止"
+AdvSceneSwitcher.action.media.type.restart="重新启动"
+AdvSceneSwitcher.action.media.type.next="下一个"
+AdvSceneSwitcher.action.media.type.previous="上一个"
+AdvSceneSwitcher.action.media.entry="{{actions}} {{mediaSources}}"
+AdvSceneSwitcher.action.macro="宏"
+AdvSceneSwitcher.action.macro.type.pause="暂停"
+AdvSceneSwitcher.action.macro.type.unpause="取消暂停"
+AdvSceneSwitcher.action.macro.type.resetCounter="复位计数器"
+AdvSceneSwitcher.action.macro.entry="{{actions}} {{macros}}"
+AdvSceneSwitcher.action.pluginState="插件状态"
+AdvSceneSwitcher.action.pluginState.type.stop="停止高级场景切换插件"
+AdvSceneSwitcher.action.pluginState.type.noMatch="没有匹配项:"
+AdvSceneSwitcher.action.pluginState.entry="{{actions}} {{values}} {{scenes}}"
+AdvSceneSwitcher.action.virtualCamera="虚拟摄像机"
+AdvSceneSwitcher.action.virtualCamera.type.stop="停止虚拟摄像机"
+AdvSceneSwitcher.action.virtualCamera.type.start="启动虚拟摄像机"
+AdvSceneSwitcher.action.virtualCamera.entry="{{actions}}"
+AdvSceneSwitcher.action.hotkey="热键"
+AdvSceneSwitcher.action.hotkey.leftShift="左 Shift"
+AdvSceneSwitcher.action.hotkey.rightShift="右 Shift"
+AdvSceneSwitcher.action.hotkey.leftCtrl="左 Ctrl"
+AdvSceneSwitcher.action.hotkey.rightCtrl="右 Ctrl"
+AdvSceneSwitcher.action.hotkey.leftAlt="左 Alt"
+AdvSceneSwitcher.action.hotkey.rightAlt="右 Alt"
+AdvSceneSwitcher.action.hotkey.leftMeta="左 Meta"
+AdvSceneSwitcher.action.hotkey.rightMeta="右 Meta"
+AdvSceneSwitcher.action.hotkey.onlyOBS="仅向OBS发送按键"
+AdvSceneSwitcher.action.hotkey.disabled="无法模拟按键-功能已禁用!"
+AdvSceneSwitcher.action.hotkey.entry="按下 {{keys}} for {{duration}} 毫秒"
+AdvSceneSwitcher.action.sceneOrder="场景项目顺序"
+AdvSceneSwitcher.action.sceneOrder.type.moveUp="上移"
+AdvSceneSwitcher.action.sceneOrder.type.moveDown="下移"
+AdvSceneSwitcher.action.sceneOrder.type.moveTop="顶部"
+AdvSceneSwitcher.action.sceneOrder.type.moveBottom="底部"
+AdvSceneSwitcher.action.sceneOrder.type.movePosition="移动到数值位置"
+AdvSceneSwitcher.action.sceneOrder.entry="在 {{scenes}} {{actions}} {{sources}} {{position}}"
+AdvSceneSwitcher.action.sceneTransform="场景项变换"
+AdvSceneSwitcher.action.sceneTransform.getTransform="得到变换"
+AdvSceneSwitcher.action.sceneTransform.entry="On {{scenes}} transform {{sources}}"
+AdvSceneSwitcher.action.file="文件"
+AdvSceneSwitcher.action.file.type.write="写入"
+AdvSceneSwitcher.action.file.type.append="追加写入"
+AdvSceneSwitcher.action.file.entry="{{actions}} to {{filePath}}:"
+AdvSceneSwitcher.action.previewScene="切换预览场景"
+AdvSceneSwitcher.action.previewScene.entry="将预览场景切换到 {{scenes}}"
+AdvSceneSwitcher.action.SceneSwap="交换场景 (Studio mode)"
+AdvSceneSwitcher.action.SceneSwap.entry="在studio模式下交换预览和编程场景"
+AdvSceneSwitcher.action.transition="过场特效"
+AdvSceneSwitcher.action.transition.entry.line1="{{setType}}将过场特效类型设置为 {{transitions}}"
+AdvSceneSwitcher.action.transition.entry.line2="{{setDuration}}将过场特效持续时间设置为 {{duration}}seconds"
+AdvSceneSwitcher.action.timer="计时器"
+AdvSceneSwitcher.action.timer.type.pause="暂停"
+AdvSceneSwitcher.action.timer.type.continue="继续"
+AdvSceneSwitcher.action.timer.type.reset="重置"
+AdvSceneSwitcher.action.timer.type.setTimeRemaining="设置剩余时间"
+AdvSceneSwitcher.action.timer.entry="{{timerAction}} 定时在 {{macros}} {{duration}}"
+AdvSceneSwitcher.action.random="随机"
+AdvSceneSwitcher.action.random.arguments="宏:"
+AdvSceneSwitcher.action.random.addArgument="增加 宏"
+AdvSceneSwitcher.action.random.entry="运行 {{macroSelection}}"
 
 ; Transition Tab
 AdvSceneSwitcher.transitionTab.title="转场特效"
+AdvSceneSwitcher.transitionTab.setTransitionBy="更改转场特效时:"
 AdvSceneSwitcher.transitionTab.transitionOverride="在场景切换器中设定的转场特效优先级高于场景设定的转场特效"
+AdvSceneSwitcher.transitionTab.adjustActiveTransitionType="更改激活转场特效类型"
 AdvSceneSwitcher.transitionTab.transitionForAToB="当自动从场景A切换到场景B时使用的转场特效"
-AdvSceneSwitcher.transitionTab.transitionsHelp="<html><head/><body><p>这里的设定<span style=\"font-style:bold;\">只影响由场景切换器引起的转场有效</span>，不影响你手动的引起的转场。<br/>在这里设定的转场特效优先级高于场景切换器其他地方设置的<br/><br/>Click the plus symbol below to continue.</p></body></html>"
+AdvSceneSwitcher.transitionTab.transitionsHelp="<html><head/><body><p>这里的设定<span style=\"font-style:bold;\">只影响由场景切换器引起的转场有效</span>，不影响你手动的引起的转场。<br/>在这里设定的转场特效优先级高于场景切换器其他地方设置的<br/><br/>单击加号添加项目.</p></body></html>"
 AdvSceneSwitcher.transitionTab.defaultTransition="当切换到这个场景时修改默认转场特效"
 AdvSceneSwitcher.transitionTab.switchDefaultLabel="活跃时切换默认转场特效为"
 AdvSceneSwitcher.transitionTab.entry="从场景 {{scenes}} 切换到场景 {{scenes2}} 时使用转场特效 {{transitions}}"
 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="当切换到这个场景时暂停场景切换器"
 AdvSceneSwitcher.pauseTab.pauseInFocus1="当窗口"
 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="窗口标题"
@@ -71,31 +393,37 @@ AdvSceneSwitcher.windowTitleTab.fullscreen="全屏时"
 AdvSceneSwitcher.windowTitleTab.maximized="最大化时"
 AdvSceneSwitcher.windowTitleTab.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="感谢dasOven的实现"
 AdvSceneSwitcher.executableTab.requiresFocus="仅获得焦点时"
 AdvSceneSwitcher.executableTab.entry="当 {{processes}} 正在运行时使用 {{transitions}} 切换到 {{scenes}} {{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}} 使用转场特效 {{transitions}} 切换到场景 {{scenes}} unless in {{excludeScenes}}"
+AdvSceneSwitcher.screenRegionTab.help="此选项卡允许您根据鼠标光标的当前位置自动切换场景。\n\n单击高亮显示的加号继续."
 
 ; Media Tab
 AdvSceneSwitcher.mediaTab.title="媒体"
 AdvSceneSwitcher.mediaTab.implemented="感谢Exeldro的实现"
-AdvSceneSwitcher.mediaTab.states.none="空"
+AdvSceneSwitcher.mediaTab.states.none="无"
 AdvSceneSwitcher.mediaTab.states.playing="播放中"
-AdvSceneSwitcher.mediaTab.states.opening="正在打开"
+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="播放时间小于"
@@ -103,6 +431,7 @@ AdvSceneSwitcher.mediaTab.timeRestriction.longer="播放时间大于"
 AdvSceneSwitcher.mediaTab.timeRestriction.remainShorter="剩余时间少于"
 AdvSceneSwitcher.mediaTab.timeRestriction.remainLonger="剩余时间多于"
 AdvSceneSwitcher.mediaTab.entry="当 {{mediaSources}} 状态为 {{states}} 并且 {{timeRestrictions}} {{time}} 时使用转场特效 {{transitions}} 切换到场景 {{scenes}}"
+AdvSceneSwitcher.mediaTab.help="此选项卡允许您根据媒体源的状态切换场景。\n例如，一旦所选媒体源结束播放，您可以自动切换回上一个场景。\n\n单击高亮显示的加号继续."
 
 ; File Tab
 AdvSceneSwitcher.fileTab.title="文件"
@@ -127,11 +456,13 @@ AdvSceneSwitcher.fileTab.checkfileContent="仅当文件发生修改时"
 AdvSceneSwitcher.fileTab.entry="如果 {{fileType}} 文件 {{filePath}} {{browseButton}} 匹配下列规则，使用转场特效 {{transitions}} 切换到场景 {{scenes}}"
 AdvSceneSwitcher.fileTab.entry2="{{matchText}}"
 AdvSceneSwitcher.fileTab.entry3="{{useRegex}} {{checkModificationDate}} {{checkFileContent}}"
+AdvSceneSwitcher.fileTab.help="此选项卡允许您根据远程或本地文件的内容自动切换场景。\n\n单击突出显示的加号继续."
 
 ; Random Tab
 AdvSceneSwitcher.randomTab.title="随机场景列表"
 AdvSceneSwitcher.randomTab.randomDisabledWarning="功能已被禁用 - 可通过在通用页设置\"如果不符合任何切换条件切换到随机场景列表中任意随机场景\"启用"
 AdvSceneSwitcher.randomTab.entry="如果没有切换器条件满足，使用转场特效 {{transitions}} 切换到场景 {{scenes}} 并停留 {{delay}}"
+AdvSceneSwitcher.randomTab.help="场景切换程序将在此选项卡上随机选择一个条目，以便在配置的时间内切换到该条目。\n请注意，同一条目不会连续选择两次。\n\n单击高亮显示的加号继续."
 
 ; Time Tab
 AdvSceneSwitcher.timeTab.title="时间"
@@ -146,15 +477,12 @@ AdvSceneSwitcher.timeTab.sundays="每周日"
 AdvSceneSwitcher.timeTab.afterstart="推流或录制开始后"
 AdvSceneSwitcher.timeTab.afterstart.tip="相对于直播或录制开始之后的时间点"
 AdvSceneSwitcher.timeTab.entry="{{triggers}} 的 {{time}} 使用转场特效 {{transitions}} 切换到场景 {{scenes}}"
+AdvSceneSwitcher.timeTab.help="此选项卡将允许您根据当前本地时间自动切换到其他场景。\n\n请注意，场景切换程序仅在您指定的确切时间切换场景。\n请确保您已根据自己的喜好在“常规”选项卡上配置了优先级设置，以便不会因其他切换而错过选定的时间点具有较高优先级的方法。\n\n单击突出显示的加号继续."
 
 ; Idle Tab
 AdvSceneSwitcher.idleTab.title="闲置检测"
 AdvSceneSwitcher.idleTab.enable="启用闲置检测"
-AdvSceneSwitcher.idleTab.condition1="超过"
-AdvSceneSwitcher.idleTab.condition2="没有鼠标或键盘操作"
-AdvSceneSwitcher.idleTab.switchToScene="切换到场景"
-AdvSceneSwitcher.idleTab.usingTransition1="使用"
-AdvSceneSwitcher.idleTab.usingTransition2="转场特效"
+AdvSceneSwitcher.idleTab.idleswitch="超过 {{duration}} 如果没有键盘或鼠标输入，则切换到场景 {{scenes}} 使用 {{transitions}}"
 AdvSceneSwitcher.idleTab.dontSwitchIfFocus1="如果当前窗口焦点在"
 AdvSceneSwitcher.idleTab.dontSwitchIfFocus2="时不切换"
 
@@ -169,35 +497,148 @@ AdvSceneSwitcher.sceneSequenceTab.loadFail="导入失败"
 AdvSceneSwitcher.sceneSequenceTab.loadSuccess="导入失败成功"
 AdvSceneSwitcher.sceneSequenceTab.fileType="文本文件 (*.txt)"
 AdvSceneSwitcher.sceneSequenceTab.entry="当场景 {{startScenes}} 被激活 {{delay}} 后使用转场特效 {{transitions}} 切换到场景 {{scenes}} {{interruptible}}"
+AdvSceneSwitcher.sceneSequenceTab.interruptible="中断"
+AdvSceneSwitcher.sceneSequenceTab.interruptibleHint="允许使用其他切换方法中断此场景序列"
+AdvSceneSwitcher.sceneSequenceTab.extendEdit="扩展序列"
+AdvSceneSwitcher.sceneSequenceTab.extendEntry="之后 {{delay}} 切换到 {{scenes}} 使用 {{transitions}}"
+AdvSceneSwitcher.sceneSequenceTab.help="如果某个场景在配置的时间段内处于活动状态，此选项卡将允许您自动切换到其他场景。\n例如，您可以自动在两个场景之间来回循环。\n\n单击高亮显示的加号继续."
 
 ; Audio Tab
 AdvSceneSwitcher.audioTab.title="音频"
-AdvSceneSwitcher.audioTab.entry="当{{audioSources}} is {{condition}} {{volumeWidget}} for {{duration}} 使用转场特效 {{transitions}} 切换到场景 {{scenes}}"
+AdvSceneSwitcher.audioTab.condition.above="高于"
+AdvSceneSwitcher.audioTab.condition.below="低于"
+AdvSceneSwitcher.audioTab.ignoreInactiveSource="除非源处于非活动状态"
+AdvSceneSwitcher.audioTab.entry="当{{audioSources}} 在 {{condition}} {{volumeWidget}} for {{duration}} 使用转场特效 {{transitions}} 切换到场景 {{scenes}}"
+AdvSceneSwitcher.audioTab.multiMatchfallbackCondition="如果多个条目匹配 ..."
+AdvSceneSwitcher.audioTab.multiMatchfallback="... for {{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.entry="当 {{videoSources}} {{condition}} {{filePath}} {{browseButton}} for {{duration}} 切换 {{scenes}} using {{transitions}} {{ignoreInactiveSource}}"
+AdvSceneSwitcher.videoTab.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.description="此选项卡将允许您远程控制另一个OBS实例的活动场景。\n请注意，所有OBS实例上的场景名称必须完全匹配."
+AdvSceneSwitcher.networkTab.warning="在本地网络之外运行服务器将允许第三方读取活动场景."
+AdvSceneSwitcher.networkTab.DisabledWarning="不幸的是，在并行运行obs websocket插件时，由于库不兼容，不得不在macOS上禁用此功能."
+AdvSceneSwitcher.networkTab.server="启动服务器（向所有连接的客户端发送场景切换消息）"
+AdvSceneSwitcher.networkTab.server.port="端口"
+AdvSceneSwitcher.networkTab.server.lockToIPv4="锁定为仅使用IPv4将服务器"
+AdvSceneSwitcher.networkTab.server.sendSceneChange="发送更改场景的消息"
+AdvSceneSwitcher.networkTab.server.restrictSendToAutomatedSwitches="仅为自动场景切换发送消息"
+AdvSceneSwitcher.networkTab.server.sendPreview="在Studio模式下运行时发送预览场景更改消息"
+AdvSceneSwitcher.networkTab.startFailed.message="WebSockets服务器无法启动，可能是因为：\n-TCP端口%1当前可能正在该系统的其他位置使用，可能是由其他应用程序使用。请尝试在WebSocket服务器设置中设置其他TCP端口，或停止可能正在使用此端口的任何应用程序。\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例如，包含场景的场景组…\n场景1\n场景2\n场景3\n。。。将在第一次选择“场景1”作为目标时激活它。\n第二次将激活“场景2”\n剩余时间将激活“场景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.sceneTriggerAction.startVirtualCamera="启动虚拟摄像机"
+AdvSceneSwitcher.sceneTriggerTab.sceneTriggerAction.stopVirtualCamera="停止虚拟摄像机"
+AdvSceneSwitcher.sceneTriggerTab.entry="当 {{scenes}} {{triggers}} {{actions}} {{audioSources}} 在 {{duration}} 后"
+AdvSceneSwitcher.sceneTriggerTab.help="此选项卡允许您在场景更改时触发操作，如停止录制或流式处理."
 
 ; Hotkey
 AdvSceneSwitcher.hotkey.startSwitcherHotkey="启动高级场景切换器"
 AdvSceneSwitcher.hotkey.stopSwitcherHotkey="停止高级场景切换器"
 AdvSceneSwitcher.hotkey.startStopToggleSwitcherHotkey="切换(启动/停止)高级场景切换器"
+AdvSceneSwitcher.hotkey.macro.pause="暂停宏 %1"
+AdvSceneSwitcher.hotkey.macro.unpause="取消暂停宏 %1"
+
+AdvSceneSwitcher.askBackup="检测到新版本的高级场景切换程序。\n是否要创建旧设置的备份?"
 
 AdvSceneSwitcher.close="关闭"
 AdvSceneSwitcher.browse="浏览文件"
 
 AdvSceneSwitcher.selectScene="--选择场景--"
+AdvSceneSwitcher.selectPreviousScene="上个场景"
+AdvSceneSwitcher.selectCurrentScene="当前场景"
+AdvSceneSwitcher.selectAnyScene="任何场景"
+AdvSceneSwitcher.currentTransition="当前转场特效"
+AdvSceneSwitcher.anyTransition="任何转场特效"
 AdvSceneSwitcher.selectTransition="--选择转场特效--"
 AdvSceneSwitcher.selectWindow="--选择窗口--"
+AdvSceneSwitcher.selectSource="--选择源--"
 AdvSceneSwitcher.selectAudioSource="--选择音频源--"
+AdvSceneSwitcher.selectVideoSource="--选择视频源--"
 AdvSceneSwitcher.selectMediaSource="--选择媒体源--"
 AdvSceneSwitcher.selectProcess="--选择进程--"
+AdvSceneSwitcher.selectFilter="--select filter--"
+AdvSceneSwitcher.selectMacro="--选择宏--"
+AdvSceneSwitcher.selectItem="--选择项目--"
 AdvSceneSwitcher.enterPath="--输入路径--"
 AdvSceneSwitcher.enterText="--输入文本--"
 AdvSceneSwitcher.invaildEntriesWillNotBeSaved="无效项将不会被保存"
-AdvSceneSwitcher.selectWindowTip="使用 \"OBS\" 来指定OBS窗口\n使用 \"Task Switching\" 来指定 Alt + Tab"
+AdvSceneSwitcher.selectWindowTip="使用 \"OBS\" 来指定OBS窗口\n使用 \"任务切换\" 来指定 Alt + Tab"
 
 AdvSceneSwitcher.status.active="运行中"
 AdvSceneSwitcher.status.inactive="已停止"
+AdvSceneSwitcher.running="插件运行"
+AdvSceneSwitcher.stopped="插件停止"
 
 AdvSceneSwitcher.unit.milliseconds="毫秒"
 AdvSceneSwitcher.unit.secends="秒"
 AdvSceneSwitcher.unit.minutes="分钟"
 AdvSceneSwitcher.unit.hours="小时"
-
+AdvSceneSwitcher.duration.condition.none="没有时间限制"
+AdvSceneSwitcher.duration.condition.more="时间少于"
+AdvSceneSwitcher.duration.condition.equal="时间等于"
+AdvSceneSwitcher.duration.condition.less="时间大于"

forms/advanced-scene-switcher.ui

@@ -545,6 +545,13 @@
           <string>AdvSceneSwitcher.macroTab.macros</string>
          </property>
          <layout class="QVBoxLayout" name="verticalLayout_36">
+          <item>
+           <widget class="QLabel" name="macroPriorityWarning">
+            <property name="text">
+             <string>AdvSceneSwitcher.macroTab.priorityWarning</string>
+            </property>
+           </widget>
+          </item>
           <item>
            <layout class="QGridLayout" name="gridLayout_26">
             <item row="0" column="0">
@@ -722,7 +729,7 @@
          </property>
          <layout class="QVBoxLayout" name="verticalLayout_34">
           <item>
-           <layout class="QHBoxLayout" name="horizontalLayout_18" stretch="0,0,0">
+           <layout class="QHBoxLayout" name="horizontalLayout_18" stretch="0,0,0,0,0">
             <item>
              <widget class="QLabel" name="label_20">
               <property name="text">
@@ -733,6 +740,20 @@
             <item>
              <widget class="QLineEdit" name="macroName"/>
             </item>
+            <item>
+             <widget class="QPushButton" name="runMacro">
+              <property name="text">
+               <string>AdvSceneSwitcher.macroTab.run</string>
+              </property>
+             </widget>
+            </item>
+            <item>
+             <widget class="QCheckBox" name="runMacroInParallel">
+              <property name="text">
+               <string>AdvSceneSwitcher.macroTab.runInParallel</string>
+              </property>
+             </widget>
+            </item>
             <item>
              <spacer name="horizontalSpacer_13">
               <property name="orientation">
@@ -763,7 +784,7 @@
                 <x>0</x>
                 <y>0</y>
                 <width>767</width>
-                <height>220</height>
+                <height>218</height>
                </rect>
               </property>
               <layout class="QVBoxLayout" name="verticalLayout_35" stretch="10,1">
@@ -862,7 +883,7 @@
                 <x>0</x>
                 <y>0</y>
                 <width>767</width>
-                <height>219</height>
+                <height>218</height>
                </rect>
               </property>
               <layout class="QVBoxLayout" name="verticalLayout_33" stretch="10,1">

src/advanced-scene-switcher.cpp

@@ -88,34 +88,6 @@ void AdvSceneSwitcher::loadUI()
 /******************************************************************************
  * Saving and loading
  ******************************************************************************/
-void 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());
-}
-
 static void SaveSceneSwitcher(obs_data_t *save_data, bool saving, void *)
 {
 	if (saving) {
@@ -126,6 +98,11 @@ static void SaveSceneSwitcher(obs_data_t *save_data, bool saving, void *)
 		obs_data_set_obj(save_data, "advanced-scene-switcher", obj);
 		obs_data_release(obj);
 	} else {
+		// Stop the scene switcher at least once to
+		// avoid scene duplication issues with scene collection changes
+		bool start = !switcher->stop;
+		switcher->Stop();
+
 		switcher->m.lock();
 		obs_data_t *obj =
 			obs_data_get_obj(save_data, "advanced-scene-switcher");
@@ -133,16 +110,12 @@ static void SaveSceneSwitcher(obs_data_t *save_data, bool saving, void *)
 			obj = obs_data_create();
 		}
 		if (switcher->versionChanged(obj, g_GIT_SHA1)) {
-			AskBackup(obj);
+			AskForBackup(obj);
 		}
 		switcher->loadSettings(obj);
 		obs_data_release(obj);
 		switcher->m.unlock();
 
-		// Stop the scene switcher at least once to
-		// avoid scene duplication issues with scene collection changes
-		bool start = !switcher->stop;
-		switcher->Stop();
 		if (start) {
 			switcher->Start();
 		}
@@ -438,9 +411,9 @@ void SwitcherData::Stop()
 {
 	if (th && th->isRunning()) {
 		stop = true;
-		cv.notify_one();
+		cv.notify_all();
 		abortMacroWait = true;
-		macroWaitCv.notify_one();
+		macroWaitCv.notify_all();
 		th->wait();
 		delete th;
 		th = nullptr;

src/general.cpp

@@ -4,9 +4,7 @@
 
 #include <QFileDialog>
 #include <QGuiApplication>
-#if __linux__
-#include <QDesktopWidget>
-#endif
+#include <QStandardPaths>
 
 QMetaObject::Connection inactivePluse;
 
@@ -231,13 +229,53 @@ void AdvSceneSwitcher::on_uiHintsDisable_stateChanged(int state)
 	switcher->disableHints = state;
 }
 
+QString getDefaultSaveLocation()
+{
+	QString desktopPath = QStandardPaths::writableLocation(
+		QStandardPaths::DesktopLocation);
+	auto scName = obs_frontend_get_current_scene_collection();
+	QString sceneCollectionName(scName);
+	bfree(scName);
+	auto timestamp = QDateTime::currentDateTime();
+	return desktopPath + "/adv-ss-" + sceneCollectionName + "-" +
+	       timestamp.toString("yyyy.MM.dd.hh.mm.ss");
+}
+
+void AskForBackup(obs_data_t *obj)
+{
+	bool backupSettings = DisplayMessage(
+		obs_module_text("AdvSceneSwitcher.askBackup"), true);
+
+	if (!backupSettings) {
+		return;
+	}
+
+	QString path = QFileDialog::getSaveFileName(
+		nullptr,
+		obs_module_text(
+			"AdvSceneSwitcher.generalTab.saveOrLoadsettings.importWindowTitle"),
+		getDefaultSaveLocation(),
+		obs_module_text(
+			"AdvSceneSwitcher.generalTab.saveOrLoadsettings.textType"));
+	if (path.isEmpty()) {
+		return;
+	}
+
+	QFile file(path);
+	if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
+		return;
+	}
+
+	obs_data_save_json(obj, file.fileName().toUtf8().constData());
+}
+
 void AdvSceneSwitcher::on_exportSettings_clicked()
 {
 	QString directory = QFileDialog::getSaveFileName(
 		this,
 		tr(obs_module_text(
 			"AdvSceneSwitcher.generalTab.saveOrLoadsettings.exportWindowTitle")),
-		QDir::currentPath(),
+		getDefaultSaveLocation(),
 		tr(obs_module_text(
 			"AdvSceneSwitcher.generalTab.saveOrLoadsettings.textType")));
 	if (directory.isEmpty()) {
@@ -400,16 +438,7 @@ void AdvSceneSwitcher::setTabOrder()
 
 bool windowPosValid(QPoint pos)
 {
-#if __linux__
-	// QDesktopWidget::availableGeometry() is deprecated.
-	// Switch to QGuiApplication::screenAt() when it is available on most Linux platforms.
-	QDesktopWidget *desktop = QApplication::desktop();
-	auto screen = desktop->availableGeometry(pos);
-	return (pos.x() > screen.x()) && (pos.y() > screen.y()) &&
-	       (pos.x() < screen.width() && (pos.y() < screen.height()));
-#else
 	return !!QGuiApplication::screenAt(pos);
-#endif
 }
 
 void AdvSceneSwitcher::restoreWindowGeo()

src/headers/advanced-scene-switcher.hpp

@@ -115,6 +115,8 @@ public slots:
 	void on_macroUp_clicked();
 	void on_macroDown_clicked();
 	void on_macroName_editingFinished();
+	void on_runMacro_clicked();
+	void on_runMacroInParallel_stateChanged(int value);
 	void on_macros_currentRowChanged(int idx);
 	void on_macros_itemChanged(QListWidgetItem *);
 	void on_conditionAdd_clicked();
@@ -285,6 +287,11 @@ void restoreTransitionOverride(obs_source_t *scene, const transitionData &td);
 void switchScene(const sceneSwitchInfo &ssi);
 void switchPreviewScene(const OBSWeakSource &ws);
 
+/******************************************************************************
+ * Settings helper
+ ******************************************************************************/
+void AskForBackup(obs_data_t *obj);
+
 /******************************************************************************
  * Main SwitcherData
  ******************************************************************************/

src/headers/macro-action-edit.hpp

@@ -5,8 +5,8 @@ struct MacroActionInfo {
 	using TCreateMethod = std::shared_ptr<MacroAction> (*)();
 	using TCreateWidgetMethod = QWidget *(*)(QWidget *parent,
 						 std::shared_ptr<MacroAction>);
-	TCreateMethod _createFunc;
-	TCreateWidgetMethod _createWidgetFunc;
+	TCreateMethod _createFunc = nullptr;
+	TCreateWidgetMethod _createWidgetFunc = nullptr;
 	std::string _name;
 };
 

src/headers/macro-action-macro.hpp

@@ -8,6 +8,7 @@ enum class PerformMacroAction {
 	PAUSE,
 	UNPAUSE,
 	RESET_COUNTER,
+	RUN,
 };
 
 class MacroActionMacro : public MacroRefAction {

src/headers/macro-action-random.hpp

@@ -4,6 +4,7 @@
 
 #include <QPushButton>
 #include <QListWidget>
+#include <QDialog>
 #include <unordered_map>
 
 class MacroActionRandom : public MultiMacroRefAction {
@@ -27,6 +28,17 @@ private:
 	static const std::string id;
 };
 
+class MacroDialog : public QDialog {
+	Q_OBJECT
+
+public:
+	MacroDialog(QWidget *parent);
+	static bool AskForMacro(QWidget *parent, std::string &macroName);
+
+private:
+	MacroSelection *_macroSelection;
+};
+
 class MacroActionRandomEdit : public QWidget {
 	Q_OBJECT
 
@@ -48,14 +60,14 @@ private slots:
 	void MacroRename(const QString &oldName, const QString &newName);
 	void AddMacro();
 	void RemoveMacro();
-	int FindEntry(const std::string &macro);
-	void MacroSelectionChanged(int idx);
 
 protected:
 	std::shared_ptr<MacroActionRandom> _entryData;
 
 private:
-	MacroSelection *_macroSelection;
+	int FindEntry(const std::string &macro);
+	void SetMacroListSize();
+
 	QListWidget *_macroList;
 	QPushButton *_add;
 	QPushButton *_remove;

src/headers/macro-action-run.hpp

@@ -56,6 +56,8 @@ protected:
 	std::shared_ptr<MacroActionRun> _entryData;
 
 private:
+	void SetArgListSize();
+
 	FileSelection *_filePath;
 	QListWidget *_argList;
 	QPushButton *_addArg;

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

@@ -21,8 +21,8 @@ public:
 
 	SceneSelection _scene;
 	OBSWeakSource _source;
-	struct obs_transform_info _info;
-	struct obs_sceneitem_crop _crop;
+	struct obs_transform_info _info = {};
+	struct obs_sceneitem_crop _crop = {};
 
 private:
 	static bool _registered;

src/headers/macro-action-screenshot.hpp

@@ -0,0 +1,50 @@
+#pragma once
+#include "macro-action-edit.hpp"
+
+class MacroActionScreenshot : 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<MacroActionScreenshot>();
+	}
+	OBSWeakSource _source;
+
+private:
+	static bool _registered;
+	static const std::string id;
+};
+
+class MacroActionScreenshotEdit : public QWidget {
+	Q_OBJECT
+
+public:
+	MacroActionScreenshotEdit(
+		QWidget *parent,
+		std::shared_ptr<MacroActionScreenshot> entryData = nullptr);
+	void UpdateEntryData();
+	static QWidget *Create(QWidget *parent,
+			       std::shared_ptr<MacroAction> action)
+	{
+		return new MacroActionScreenshotEdit(
+			parent,
+			std::dynamic_pointer_cast<MacroActionScreenshot>(
+				action));
+	}
+private slots:
+	void SourceChanged(const QString &text);
+signals:
+	void HeaderInfoChanged(const QString &);
+
+protected:
+	QComboBox *_sources;
+	std::shared_ptr<MacroActionScreenshot> _entryData;
+
+private:
+	bool _loading = true;
+};

src/headers/macro-action-systray.hpp

@@ -0,0 +1,49 @@
+#pragma once
+#include "macro-action-edit.hpp"
+
+#include <QLineEdit>
+
+class MacroActionSystray : 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<MacroActionSystray>();
+	}
+
+	std::string _msg = "";
+
+private:
+	static bool _registered;
+	static const std::string id;
+};
+
+class MacroActionSystrayEdit : public QWidget {
+	Q_OBJECT
+
+public:
+	MacroActionSystrayEdit(
+		QWidget *parent,
+		std::shared_ptr<MacroActionSystray> entryData = nullptr);
+	static QWidget *Create(QWidget *parent,
+			       std::shared_ptr<MacroAction> action)
+	{
+		return new MacroActionSystrayEdit(
+			parent,
+			std::dynamic_pointer_cast<MacroActionSystray>(action));
+	}
+
+private slots:
+	void MessageChanged();
+
+protected:
+	std::shared_ptr<MacroActionSystray> _entryData;
+
+private:
+	QLineEdit *_msg;
+	bool _loading = true;
+};

src/headers/macro-condition-edit.hpp

@@ -5,8 +5,8 @@ struct MacroConditionInfo {
 	using TCreateMethod = std::shared_ptr<MacroCondition> (*)();
 	using TCreateWidgetMethod =
 		QWidget *(*)(QWidget *parent, std::shared_ptr<MacroCondition>);
-	TCreateMethod _createFunc;
-	TCreateWidgetMethod _createWidgetFunc;
+	TCreateMethod _createFunc = nullptr;
+	TCreateWidgetMethod _createWidgetFunc = nullptr;
 	std::string _name;
 	bool _useDurationConstraint = true;
 };

src/headers/macro-condition-media.hpp

@@ -3,8 +3,10 @@
 #include <limits>
 #include <QWidget>
 #include <QComboBox>
+#include <QCheckBox>
 
 #include "duration-control.hpp"
+#include "scene-selection.hpp"
 
 enum class MediaTimeRestriction {
 	TIME_RESTRICTION_NONE,
@@ -33,6 +35,12 @@ enum class MediaState {
 	ANY,
 };
 
+enum class MediaSourceType {
+	SOURCE,
+	ANY,
+	ALL,
+};
+
 class MacroConditionMedia : public MacroCondition {
 public:
 	~MacroConditionMedia();
@@ -50,15 +58,23 @@ public:
 	static void MediaStopped(void *data, calldata_t *);
 	static void MediaEnded(void *data, calldata_t *);
 
+	MediaSourceType _sourceType = MediaSourceType::SOURCE;
+	SceneSelection _scene;
 	OBSWeakSource _source = nullptr;
+	std::vector<MacroConditionMedia> _sources;
 	MediaState _state = MediaState::OBS_MEDIA_STATE_NONE;
 	MediaTimeRestriction _restriction =
 		MediaTimeRestriction::TIME_RESTRICTION_NONE;
 	Duration _time;
+	bool _onlyMatchonChagne = false;
 
 private:
-	std::atomic_bool _stopped = {false};
-	std::atomic_bool _ended = {false};
+	bool CheckMediaMatch();
+
+	bool _stopped = false;
+	bool _ended = false;
+	// TODO: Remove _alreadyMatched as it does not make much sense when
+	// time restrictions for macro conditions are available.
 	// Trigger scene change only once even if media state might trigger repeatedly
 	bool _alreadyMatched = false;
 	// Workaround to enable use of "ended" to specify end of VLC playlist
@@ -87,20 +103,25 @@ public:
 
 private slots:
 	void SourceChanged(const QString &text);
+	void SceneChanged(const SceneSelection &);
 	void StateChanged(int index);
 	void TimeRestrictionChanged(int index);
 	void TimeChanged(double seconds);
 	void TimeUnitChanged(DurationUnit unit);
+	void OnChangeChanged(int);
 signals:
 	void HeaderInfoChanged(const QString &);
 
 protected:
+	SceneSelectionWidget *_scenes;
 	QComboBox *_mediaSources;
 	QComboBox *_states;
 	QComboBox *_timeRestrictions;
 	DurationSelection *_time;
+	QCheckBox *_onChange;
 	std::shared_ptr<MacroConditionMedia> _entryData;
 
 private:
+	void SetWidgetVisibility();
 	bool _loading = true;
 };

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

@@ -5,6 +5,7 @@
 
 enum class PluginStateCondition {
 	SCENESWITCHED,
+	RUNNING,
 };
 
 class MacroConditionPluginState : public MacroCondition {

src/headers/macro-condition-recording.hpp

@@ -20,7 +20,7 @@ public:
 		return std::make_shared<MacroConditionRecord>();
 	}
 
-	RecordState _recordState;
+	RecordState _recordState = RecordState::STOP;
 
 private:
 	static bool _registered;

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

@@ -22,7 +22,7 @@ public:
 		return std::make_shared<MacroConditionReplayBuffer>();
 	}
 
-	ReplayBufferState _state;
+	ReplayBufferState _state = ReplayBufferState::STOP;
 
 private:
 	static bool _registered;

src/headers/macro-condition-scene.hpp

@@ -25,9 +25,12 @@ public:
 		return std::make_shared<MacroConditionScene>();
 	}
 
-	bool _waitForTransition = false;
+	// This option is to be removed in a future version and be replaced by
+	// transition specific conditions
+	bool _waitForTransition = true;
+
 	SceneSelection _scene;
-	SceneType _type;
+	SceneType _type = SceneType::CURRENT;
 
 private:
 	std::chrono::high_resolution_clock::time_point _lastSceneChangeTime{};

src/headers/macro-condition-streaming.hpp

@@ -21,7 +21,7 @@ public:
 		return std::make_shared<MacroConditionStream>();
 	}
 
-	StreamState _streamState;
+	StreamState _streamState = StreamState::STOP;
 
 private:
 	std::chrono::high_resolution_clock::time_point _lastStreamStartingTime{};

src/headers/macro-condition-timer.hpp

@@ -5,6 +5,15 @@
 #include <QCheckBox>
 #include <QPushButton>
 #include <QTimer>
+#include <QComboBox>
+#include <QHBoxLayout>
+
+#include <random>
+
+enum class TimerType {
+	FIXED,
+	RANDOM,
+};
 
 class MacroConditionTimer : public MacroCondition {
 public:
@@ -20,13 +29,17 @@ public:
 	void Continue();
 	void Reset();
 
+	TimerType _type = TimerType::FIXED;
 	Duration _duration;
+	Duration _duration2;
 	bool _paused = false;
 	bool _saveRemaining = false;
 	double _remaining = 0.;
 	bool _oneshot = false;
 
 private:
+	void SetRandomTimeRemaining();
+	std::default_random_engine _re;
 	static bool _registered;
 	static const std::string id;
 };
@@ -48,8 +61,11 @@ public:
 	}
 
 private slots:
+	void TimerTypeChanged(int type);
 	void DurationChanged(double seconds);
 	void DurationUnitChanged(DurationUnit unit);
+	void Duration2Changed(double seconds);
+	void Duration2UnitChanged(DurationUnit unit);
 	void SaveRemainingChanged(int state);
 	void AutoResetChanged(int state);
 	void PauseContinueClicked();
@@ -59,7 +75,9 @@ private slots:
 protected:
 	void SetPauseContinueButtonLabel();
 
+	QComboBox *_timerTypes;
 	DurationSelection *_duration;
+	DurationSelection *_duration2;
 	QCheckBox *_autoReset;
 	QCheckBox *_saveRemaining;
 	QPushButton *_reset;
@@ -68,6 +86,9 @@ protected:
 	std::shared_ptr<MacroConditionTimer> _entryData;
 
 private:
+	void SetWidgetVisibility();
+
+	QHBoxLayout *_timerLayout;
 	QTimer timer;
 	bool _loading = true;
 };

src/headers/macro-condition-transition.hpp

@@ -2,6 +2,7 @@
 #include "macro.hpp"
 #include "duration-control.hpp"
 #include "transition-selection.hpp"
+#include "scene-selection.hpp"
 
 #include <QWidget>
 #include <QComboBox>
@@ -11,6 +12,8 @@ enum class TransitionCondition {
 	DURATION,
 	STARTED,
 	ENDED,
+	TRANSITION_SOURCE,
+	TRANSITION_TARGET,
 };
 
 class MacroConditionTransition : public MacroCondition {
@@ -29,6 +32,7 @@ public:
 
 	TransitionCondition _condition = TransitionCondition::CURRENT;
 	TransitionSelection _transition;
+	SceneSelection _scene;
 	Duration _duration;
 
 private:
@@ -62,6 +66,7 @@ public:
 private slots:
 	void ConditionChanged(int cond);
 	void TransitionChanged(const TransitionSelection &);
+	void SceneChanged(const SceneSelection &);
 	void DurationChanged(double seconds);
 signals:
 	void HeaderInfoChanged(const QString &);
@@ -69,6 +74,7 @@ signals:
 protected:
 	QComboBox *_conditions;
 	TransitionSelectionWidget *_transitions;
+	SceneSelectionWidget *_scenes;
 	DurationSelection *_duration;
 	QLabel *_durationSuffix;
 	std::shared_ptr<MacroConditionTransition> _entryData;

src/headers/macro-condition-video.hpp

@@ -8,6 +8,7 @@
 #include <QCheckBox>
 #include <QHBoxLayout>
 #include <chrono>
+#undef NO // MacOS macro that can conflict with OpenCV
 #include <opencv2/opencv.hpp>
 
 enum class VideoCondition {

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

@@ -21,7 +21,7 @@ public:
 		return std::make_shared<MacroConditionVCam>();
 	}
 
-	VCamState _state;
+	VCamState _state = VCamState::STOP;
 
 private:
 	static bool _registered;

src/headers/macro-segment.hpp

@@ -14,7 +14,7 @@ public:
 	virtual std::string GetId() = 0;
 
 protected:
-	int _idx;
+	int _idx = 0;
 	bool _collapsed = false;
 };
 

src/headers/macro.hpp

@@ -2,16 +2,16 @@
 #include "macro-segment.hpp"
 #include "duration-control.hpp"
 
+#include <QString>
 #include <string>
 #include <deque>
 #include <memory>
 #include <map>
+#include <thread>
 #include <obs.hpp>
 #include <obs-module.h>
-#include <QString>
 
 constexpr auto macro_func = 10;
-constexpr auto default_priority_10 = macro_func;
 
 constexpr auto logic_root_offset = 100;
 
@@ -55,7 +55,7 @@ public:
 	void SetDuration(double seconds);
 
 private:
-	LogicType _logic;
+	LogicType _logic = LogicType::ROOT_NONE;
 	DurationConstraint _duration;
 };
 
@@ -73,10 +73,12 @@ public:
 	virtual ~Macro();
 
 	bool CeckMatch();
-	bool PerformAction();
+	bool PerformAction(bool forceParallel = false);
 	bool Matched() { return _matched; }
 	std::string Name() { return _name; }
 	void SetName(const std::string &name);
+	void SetRunInParallel(bool parallel) { _runInParallel = parallel; }
+	bool RunInParallel() { return _runInParallel; }
 	void SetPaused(bool pause = true);
 	bool Paused() { return _paused; }
 	int GetCount() { return _count; };
@@ -103,15 +105,23 @@ private:
 	void ClearHotkeys();
 	void SetHotkeysDesc();
 	void ResetTimers();
+	void RunActions(bool &ret);
+	void RunActions();
 
 	std::string _name = "";
 	std::deque<std::shared_ptr<MacroCondition>> _conditions;
 	std::deque<std::shared_ptr<MacroAction>> _actions;
+	bool _runInParallel = false;
 	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;
+	obs_hotkey_id _togglePauseHotkey = OBS_INVALID_HOTKEY_ID;
+
+	bool _stop = false;
+	bool _done = true;
+	std::thread _thread;
 };
 
 Macro *GetMacroByName(const char *name);

src/headers/switch-audio.hpp

@@ -14,7 +14,6 @@
 #include "volume-control.hpp"
 
 constexpr auto audio_func = 8;
-constexpr auto default_priority_8 = audio_func;
 
 typedef enum {
 	ABOVE,
@@ -44,7 +43,7 @@ struct AudioSwitch : virtual SceneSwitcherEntry {
 
 	AudioSwitch(){};
 	AudioSwitch(const AudioSwitch &other);
-	AudioSwitch(AudioSwitch &&other);
+	AudioSwitch(AudioSwitch &&other) noexcept;
 	~AudioSwitch();
 	AudioSwitch &operator=(const AudioSwitch &other);
 	AudioSwitch &operator=(AudioSwitch &&other) noexcept;

src/headers/switch-executable.hpp

@@ -10,7 +10,6 @@
 #include "switch-generic.hpp"
 
 constexpr auto exe_func = 3;
-constexpr auto default_priority_3 = exe_func;
 
 struct ExecutableSwitch : SceneSwitcherEntry {
 	static bool pause;

src/headers/switch-file.hpp

@@ -11,7 +11,6 @@
 #include <obs-module.h>
 
 constexpr auto read_file_func = 0;
-constexpr auto default_priority_0 = read_file_func;
 
 typedef enum {
 	LOCAL,

src/headers/switch-idle.hpp

@@ -10,7 +10,6 @@
 
 constexpr auto default_idle_time = 60;
 constexpr auto idle_func = 2;
-constexpr auto default_priority_2 = idle_func;
 
 struct IdleData : SceneSwitcherEntry {
 	static bool pause;

src/headers/switch-media.hpp

@@ -9,7 +9,6 @@
 #include "switch-generic.hpp"
 
 constexpr auto media_func = 6;
-constexpr auto default_priority_6 = media_func;
 
 typedef enum {
 	TIME_RESTRICTION_NONE,
@@ -52,7 +51,7 @@ struct MediaSwitch : SceneSwitcherEntry {
 	inline MediaSwitch(){};
 
 	MediaSwitch(const MediaSwitch &other);
-	MediaSwitch(MediaSwitch &&other);
+	MediaSwitch(MediaSwitch &&other) noexcept;
 	~MediaSwitch();
 	MediaSwitch &operator=(const MediaSwitch &other);
 	MediaSwitch &operator=(MediaSwitch &&other) noexcept;

src/headers/switch-network.hpp

@@ -70,8 +70,8 @@ private:
 	QString getRemoteEndpoint(connection_hdl hdl);
 
 	server _server;
-	quint16 _serverPort;
-	bool _lockToIPv4;
+	quint16 _serverPort = 55555;
+	bool _lockToIPv4 = false;
 	std::set<connection_hdl, std::owner_less<connection_hdl>> _connections;
 	QMutex _clMutex;
 	QThreadPool _threadPool;

src/headers/switch-screen-region.hpp

@@ -10,7 +10,6 @@
 #include "switch-generic.hpp"
 
 constexpr auto screen_region_func = 4;
-constexpr auto default_priority_4 = screen_region_func;
 
 struct ScreenRegionSwitch : SceneSwitcherEntry {
 	static bool pause;

src/headers/switch-sequence.hpp

@@ -12,7 +12,6 @@
 #include "duration-control.hpp"
 
 constexpr auto round_trip_func = 1;
-constexpr auto default_priority_1 = round_trip_func;
 
 struct SceneSequenceSwitch : SceneSwitcherEntry {
 	static bool pause;

src/headers/switch-time.hpp

@@ -11,7 +11,6 @@
 #include "switch-generic.hpp"
 
 constexpr auto time_func = 7;
-constexpr auto default_priority_7 = time_func;
 
 typedef enum {
 	ANY_DAY = 0,

src/headers/switch-video.hpp

@@ -12,7 +12,6 @@
 #include "screenshot-helper.hpp"
 
 constexpr auto video_func = 9;
-constexpr auto default_priority_9 = video_func;
 
 enum class videoSwitchType {
 	MATCH,

src/headers/switch-window.hpp

@@ -9,7 +9,6 @@
 #include "switch-generic.hpp"
 
 constexpr auto window_title_func = 5;
-constexpr auto default_priority_5 = window_title_func;
 
 struct WindowSwitch : SceneSwitcherEntry {
 	static bool pause;

src/headers/switcher-data-structs.hpp

@@ -33,6 +33,18 @@ constexpr auto previous_scene_name = "Previous Scene";
 constexpr auto current_transition_name = "Current Transition";
 constexpr auto tab_count = 18;
 
+constexpr auto default_priority_0 = macro_func;
+constexpr auto default_priority_1 = read_file_func;
+constexpr auto default_priority_2 = idle_func;
+constexpr auto default_priority_3 = audio_func;
+constexpr auto default_priority_4 = media_func;
+constexpr auto default_priority_5 = video_func;
+constexpr auto default_priority_6 = time_func;
+constexpr auto default_priority_7 = screen_region_func;
+constexpr auto default_priority_8 = round_trip_func;
+constexpr auto default_priority_9 = window_title_func;
+constexpr auto default_priority_10 = exe_func;
+
 typedef enum { NO_SWITCH = 0, SWITCH = 1, RANDOM_SWITCH = 2 } NoMatch;
 typedef enum { PERSIST = 0, START = 1, STOP = 2 } StartupBehavior;
 
@@ -88,7 +100,7 @@ struct SwitcherData {
 	std::chrono::high_resolution_clock::time_point lastStreamStartingTime{};
 	std::chrono::high_resolution_clock::time_point lastStreamStoppingTime{};
 	OBSWeakSource lastRandomScene;
-	SceneGroup *lastRandomSceneGroup;
+	SceneGroup *lastRandomSceneGroup = nullptr;
 	OBSWeakSource nonMatchingScene;
 	NoMatch switchIfNotMatching = NO_SWITCH;
 	Duration noMatchDelay;

src/headers/utility.hpp

@@ -55,6 +55,7 @@ void listAddClicked(QListWidget *list, QWidget *newWidget,
 		    QMetaObject::Connection *addHighlight = nullptr);
 bool listMoveUp(QListWidget *list);
 bool listMoveDown(QListWidget *list);
+void setHeightToContentHeight(QListWidget *list);
 bool DisplayMessage(const QString &msg, bool question = false);
 void DisplayTrayMessage(const QString &title, const QString &msg);
 void addSelectionEntry(QComboBox *sel, const char *description,
@@ -63,7 +64,8 @@ void populateTransitionSelection(QComboBox *sel, bool addCurrent = true,
 				 bool addAny = false);
 void populateWindowSelection(QComboBox *sel, bool addSelect = true);
 void populateAudioSelection(QComboBox *sel, bool addSelect = true);
-void populateVideoSelection(QComboBox *sel, bool addSelect = true);
+void populateVideoSelection(QComboBox *sel, bool addScenes = false,
+			    bool addSelect = true);
 void populateMediaSelection(QComboBox *sel, bool addSelect = true);
 void populateProcessSelection(QComboBox *sel, bool addSelect = true);
 void populateSourceSelection(QComboBox *list, bool addSelect = true);

src/macro-action-edit.cpp

@@ -184,7 +184,7 @@ void AdvSceneSwitcher::RemoveMacroAction(int idx)
 	std::lock_guard<std::mutex> lock(switcher->m);
 	macro->Actions().erase(macro->Actions().begin() + idx);
 	switcher->abortMacroWait = true;
-	switcher->macroWaitCv.notify_one();
+	switcher->macroWaitCv.notify_all();
 	macro->UpdateActionIndices();
 
 	clearLayout(ui->macroEditActionLayout, idx);

src/macro-action-macro.cpp

@@ -15,6 +15,7 @@ const static std::map<PerformMacroAction, std::string> actionTypes = {
 	 "AdvSceneSwitcher.action.macro.type.unpause"},
 	{PerformMacroAction::RESET_COUNTER,
 	 "AdvSceneSwitcher.action.macro.type.resetCounter"},
+	{PerformMacroAction::RUN, "AdvSceneSwitcher.action.macro.type.run"},
 };
 
 bool MacroActionMacro::PerformAction()
@@ -33,6 +34,9 @@ bool MacroActionMacro::PerformAction()
 	case PerformMacroAction::RESET_COUNTER:
 		_macro->ResetCount();
 		break;
+	case PerformMacroAction::RUN:
+		_macro->PerformAction();
+		break;
 	default:
 		break;
 	}
@@ -55,6 +59,10 @@ void MacroActionMacro::LogAction()
 		vblog(LOG_INFO, "reset counter for \"%s\"",
 		      _macro->Name().c_str());
 		break;
+	case PerformMacroAction::RUN:
+		vblog(LOG_INFO, "run nested macro \"%s\"",
+		      _macro->Name().c_str());
+		break;
 	default:
 		break;
 	}

src/macro-action-random.cpp

@@ -3,6 +3,7 @@
 #include "headers/name-dialog.hpp"
 #include "headers/utility.hpp"
 
+#include <QDialogButtonBox>
 #include <cstdlib>
 
 const std::string MacroActionRandom::id = "random";
@@ -93,7 +94,6 @@ MacroActionRandomEdit::MacroActionRandomEdit(
 	QWidget *parent, std::shared_ptr<MacroActionRandom> entryData)
 	: QWidget(parent)
 {
-	_macroSelection = new MacroSelection(window());
 	_macroList = new QListWidget();
 	_macroList->setSortingEnabled(true);
 	_add = new QPushButton();
@@ -117,9 +117,7 @@ MacroActionRandomEdit::MacroActionRandomEdit(
 			 SLOT(MacroRename(const QString &, const QString &)));
 
 	auto *entryLayout = new QHBoxLayout;
-	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
-		{"{{macroSelection}}", _macroSelection},
-	};
+	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {};
 	placeWidgets(obs_module_text("AdvSceneSwitcher.action.random.entry"),
 		     entryLayout, widgetPlaceholders);
 
@@ -130,8 +128,6 @@ MacroActionRandomEdit::MacroActionRandomEdit(
 
 	auto *mainLayout = new QVBoxLayout;
 	mainLayout->addLayout(entryLayout);
-	mainLayout->addWidget(new QLabel(
-		obs_module_text("AdvSceneSwitcher.action.random.arguments")));
 	mainLayout->addWidget(_macroList);
 	mainLayout->addLayout(argButtonLayout);
 	setLayout(mainLayout);
@@ -155,6 +151,7 @@ void MacroActionRandomEdit::UpdateEntryData()
 		QListWidgetItem *item = new QListWidgetItem(name, _macroList);
 		item->setData(Qt::UserRole, name);
 	}
+	SetMacroListSize();
 }
 
 void MacroActionRandomEdit::MacroRemove(const QString &name)
@@ -192,8 +189,14 @@ void MacroActionRandomEdit::AddMacro()
 		return;
 	}
 
-	auto macroName = _macroSelection->currentText();
-	MacroRef macro(macroName.toStdString());
+	std::string macroName;
+	bool accepted = MacroDialog::AskForMacro(this, macroName);
+
+	if (!accepted || macroName.empty()) {
+		return;
+	}
+
+	MacroRef macro(macroName);
 
 	if (!macro.get()) {
 		return;
@@ -203,12 +206,14 @@ void MacroActionRandomEdit::AddMacro()
 		return;
 	}
 
-	QVariant v = QVariant::fromValue(macroName);
-	QListWidgetItem *item = new QListWidgetItem(macroName, _macroList);
-	item->setData(Qt::UserRole, macroName);
+	QVariant v = QVariant::fromValue(QString::fromStdString(macroName));
+	QListWidgetItem *item = new QListWidgetItem(
+		QString::fromStdString(macroName), _macroList);
+	item->setData(Qt::UserRole, QString::fromStdString(macroName));
 
 	std::lock_guard<std::mutex> lock(switcher->m);
 	_entryData->_macros.push_back(macro);
+	SetMacroListSize();
 }
 
 void MacroActionRandomEdit::RemoveMacro()
@@ -232,6 +237,7 @@ void MacroActionRandomEdit::RemoveMacro()
 		}
 	}
 	delete item;
+	SetMacroListSize();
 }
 
 int MacroActionRandomEdit::FindEntry(const std::string &macro)
@@ -251,13 +257,52 @@ int MacroActionRandomEdit::FindEntry(const std::string &macro)
 	return idx;
 }
 
-void MacroActionRandomEdit::MacroSelectionChanged(int idx)
+void MacroActionRandomEdit::SetMacroListSize()
 {
-	if (_loading || !_entryData || idx == -1) {
-		return;
+	setHeightToContentHeight(_macroList);
+	adjustSize();
+}
+
+MacroDialog::MacroDialog(QWidget *)
+{
+	setModal(true);
+	setWindowModality(Qt::WindowModality::ApplicationModal);
+	setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
+	setMinimumWidth(350);
+	setMinimumHeight(70);
+
+	QDialogButtonBox *buttonbox = new QDialogButtonBox(
+		QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
+
+	buttonbox->setCenterButtons(true);
+	connect(buttonbox, &QDialogButtonBox::accepted, this, &QDialog::accept);
+	connect(buttonbox, &QDialogButtonBox::rejected, this, &QDialog::reject);
+
+	_macroSelection = new MacroSelection(window());
+	auto *selectionLayout = new QHBoxLayout;
+	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
+		{"{{macroSelection}}", _macroSelection},
+	};
+	placeWidgets(obs_module_text("AdvSceneSwitcher.askForMacro"),
+		     selectionLayout, widgetPlaceholders);
+	auto *layout = new QVBoxLayout();
+	layout->addLayout(selectionLayout);
+	layout->addWidget(buttonbox);
+	setLayout(layout);
+}
+
+bool MacroDialog::AskForMacro(QWidget *parent, std::string &macroName)
+{
+	MacroDialog dialog(parent);
+	dialog.setWindowTitle(obs_module_text("AdvSceneSwitcher.windowTitle"));
+
+	if (dialog.exec() != DialogCode::Accepted) {
+		return false;
+	}
+	macroName = dialog._macroSelection->currentText().toUtf8().constData();
+	if (macroName == obs_module_text("AdvSceneSwitcher.selectMacro")) {
+		return false;
 	}
 
-	QListWidgetItem *item = _macroList->item(idx);
-	QString name = item->text();
-	_macroSelection->SetCurrentMacro(GetMacroByName(name.toUtf8().data()));
+	return true;
 }

src/macro-action-run.cpp

@@ -5,6 +5,7 @@
 
 #include <QProcess>
 #include <QFileDialog>
+#include <QDesktopServices>
 
 const std::string MacroActionRun::id = "run";
 
@@ -14,7 +15,13 @@ bool MacroActionRun::_registered = MacroActionFactory::Register(
 
 bool MacroActionRun::PerformAction()
 {
-	QProcess::startDetached(QString::fromStdString(_path), _args);
+	if (!QProcess::startDetached(QString::fromStdString(_path), _args) &&
+	    _args.empty()) {
+		vblog(LOG_INFO, "run \"%s\" using QDesktopServices",
+		      _path.c_str());
+		QDesktopServices::openUrl(
+			QUrl::fromLocalFile(QString::fromStdString(_path)));
+	}
 	return true;
 }
 
@@ -137,6 +144,7 @@ void MacroActionRunEdit::UpdateEntryData()
 		QListWidgetItem *item = new QListWidgetItem(arg, _argList);
 		item->setData(Qt::UserRole, arg);
 	}
+	SetArgListSize();
 }
 
 void MacroActionRunEdit::PathChanged(const QString &text)
@@ -175,6 +183,7 @@ void MacroActionRunEdit::AddArg()
 
 	std::lock_guard<std::mutex> lock(switcher->m);
 	_entryData->_args << arg;
+	SetArgListSize();
 }
 
 void MacroActionRunEdit::RemoveArg()
@@ -195,6 +204,7 @@ void MacroActionRunEdit::RemoveArg()
 		return;
 	}
 	delete item;
+	SetArgListSize();
 }
 
 void MacroActionRunEdit::ArgUp()
@@ -224,3 +234,9 @@ void MacroActionRunEdit::ArgDown()
 		_entryData->_args.move(idx, idx + 1);
 	}
 }
+
+void MacroActionRunEdit::SetArgListSize()
+{
+	setHeightToContentHeight(_argList);
+	adjustSize();
+}

src/macro-action-screenshot.cpp

@@ -0,0 +1,110 @@
+#include "headers/macro-action-screenshot.hpp"
+#include "headers/advanced-scene-switcher.hpp"
+#include "headers/utility.hpp"
+
+const std::string MacroActionScreenshot::id = "screenshot";
+
+bool MacroActionScreenshot::_registered = MacroActionFactory::Register(
+	MacroActionScreenshot::id,
+	{MacroActionScreenshot::Create, MacroActionScreenshotEdit::Create,
+	 "AdvSceneSwitcher.action.screenshot"});
+
+bool MacroActionScreenshot::PerformAction()
+{
+	if (_source) {
+		auto s = obs_weak_source_get_source(_source);
+		obs_frontend_take_source_screenshot(s);
+		obs_source_release(s);
+	} else {
+		obs_frontend_take_screenshot();
+	}
+	return true;
+}
+
+void MacroActionScreenshot::LogAction()
+{
+	vblog(LOG_INFO, "trigger screenshot for source \"%s\"",
+	      GetWeakSourceName(_source).c_str());
+}
+
+bool MacroActionScreenshot::Save(obs_data_t *obj)
+{
+	MacroAction::Save(obj);
+	obs_data_set_string(obj, "source", GetWeakSourceName(_source).c_str());
+	return true;
+}
+
+bool MacroActionScreenshot::Load(obs_data_t *obj)
+{
+	MacroAction::Load(obj);
+	const char *sourceName = obs_data_get_string(obj, "source");
+	_source = GetWeakSourceByName(sourceName);
+	return true;
+}
+
+std::string MacroActionScreenshot::GetShortDesc()
+{
+	if (_source) {
+		return GetWeakSourceName(_source);
+	}
+	return "";
+}
+
+void addOBSMainOutputEntry(QComboBox *cb)
+{
+	cb->insertItem(
+		0, obs_module_text(
+			   "AdvSceneSwitcher.action.screenshot.mainOutput"));
+}
+
+MacroActionScreenshotEdit::MacroActionScreenshotEdit(
+	QWidget *parent, std::shared_ptr<MacroActionScreenshot> entryData)
+	: QWidget(parent)
+{
+	_sources = new QComboBox();
+	populateVideoSelection(_sources, true, false);
+	addOBSMainOutputEntry(_sources);
+
+	QWidget::connect(_sources, SIGNAL(currentTextChanged(const QString &)),
+			 this, SLOT(SourceChanged(const QString &)));
+
+	QHBoxLayout *mainLayout = new QHBoxLayout;
+	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
+		{"{{sources}}", _sources},
+	};
+	placeWidgets(
+		obs_module_text("AdvSceneSwitcher.action.screenshot.entry"),
+		mainLayout, widgetPlaceholders);
+
+	setLayout(mainLayout);
+
+	_entryData = entryData;
+	UpdateEntryData();
+	_loading = false;
+}
+
+void MacroActionScreenshotEdit::UpdateEntryData()
+{
+	if (!_entryData) {
+		return;
+	}
+
+	if (_entryData->_source) {
+		_sources->setCurrentText(
+			GetWeakSourceName(_entryData->_source).c_str());
+	} else {
+		_sources->setCurrentIndex(0);
+	}
+}
+
+void MacroActionScreenshotEdit::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()));
+}

src/macro-action-systray.cpp

@@ -0,0 +1,70 @@
+#include "headers/macro-action-systray.hpp"
+#include "headers/advanced-scene-switcher.hpp"
+#include "headers/utility.hpp"
+
+const std::string MacroActionSystray::id = "systray_notification";
+
+bool MacroActionSystray::_registered = MacroActionFactory::Register(
+	MacroActionSystray::id,
+	{MacroActionSystray::Create, MacroActionSystrayEdit::Create,
+	 "AdvSceneSwitcher.action.systray"});
+
+bool MacroActionSystray::PerformAction()
+{
+	if (_msg.empty()) {
+		return true;
+	}
+	DisplayTrayMessage(obs_module_text("AdvSceneSwitcher.pluginName"),
+			   QString::fromStdString(_msg));
+	return true;
+}
+
+void MacroActionSystray::LogAction()
+{
+	vblog(LOG_INFO, "display systray message \"%s\"", _msg.c_str());
+}
+
+bool MacroActionSystray::Save(obs_data_t *obj)
+{
+	MacroAction::Save(obj);
+	obs_data_set_string(obj, "message", _msg.c_str());
+	return true;
+}
+
+bool MacroActionSystray::Load(obs_data_t *obj)
+{
+	MacroAction::Load(obj);
+	_msg = obs_data_get_string(obj, "message");
+	return true;
+}
+
+MacroActionSystrayEdit::MacroActionSystrayEdit(
+	QWidget *parent, std::shared_ptr<MacroActionSystray> entryData)
+	: QWidget(parent)
+{
+	_msg = new QLineEdit();
+	QWidget::connect(_msg, SIGNAL(editingFinished()), this,
+			 SLOT(MessageChanged()));
+
+	QHBoxLayout *mainLayout = new QHBoxLayout;
+	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
+		{"{{message}}", _msg},
+	};
+	placeWidgets(obs_module_text("AdvSceneSwitcher.action.systray.entry"),
+		     mainLayout, widgetPlaceholders);
+	setLayout(mainLayout);
+
+	_entryData = entryData;
+	_msg->setText(QString::fromStdString(_entryData->_msg));
+	_loading = false;
+}
+
+void MacroActionSystrayEdit::MessageChanged()
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_msg = _msg->text().toStdString();
+}

src/macro-condition-media.cpp

@@ -80,18 +80,19 @@ bool matchTime(const int64_t currentTime, const int64_t duration,
 	       matchedTimeRemainLonger || matchedTimeRemainShorter;
 }
 
-bool MacroConditionMedia::CheckCondition()
+bool MacroConditionMedia::CheckMediaMatch()
 {
+
 	if (!_source) {
 		return false;
 	}
 	bool match = false;
 
-	obs_source_t *source = obs_weak_source_get_source(_source);
-	auto duration = obs_source_media_get_duration(source);
-	auto time = obs_source_media_get_time(source);
-	obs_media_state currentState = obs_source_media_get_state(source);
-	obs_source_release(source);
+	obs_source_t *s = obs_weak_source_get_source(_source);
+	auto duration = obs_source_media_get_duration(s);
+	auto time = obs_source_media_get_time(s);
+	obs_media_state currentState = obs_source_media_get_state(s);
+	obs_source_release(s);
 
 	// To be able to compare to obs_media_state more easily
 	int expectedState = static_cast<int>(_state);
@@ -150,49 +151,149 @@ bool MacroConditionMedia::CheckCondition()
 		matchTime(time, duration, _restriction, _time.seconds * 1000);
 	bool matched = matchedState && matchedTime;
 
-	if (matched && !_alreadyMatched) {
+	if (matched && !(_onlyMatchonChagne && _alreadyMatched)) {
 		match = true;
 	}
-
 	_alreadyMatched = matched;
 
 	return match;
 }
 
+bool MacroConditionMedia::CheckCondition()
+{
+	bool match = false;
+	switch (_sourceType) {
+	case MediaSourceType::ANY:
+		for (auto &source : _sources) {
+			match = match || source.CheckCondition();
+		}
+		break;
+	case MediaSourceType::ALL: {
+		bool res = true;
+		for (auto &source : _sources) {
+			res = res && source.CheckCondition();
+		}
+		match = res;
+		break;
+	}
+	case MediaSourceType::SOURCE:
+		match = CheckMediaMatch();
+		break;
+	default:
+		break;
+	}
+	return match;
+}
+
 bool MacroConditionMedia::Save(obs_data_t *obj)
 {
 	MacroCondition::Save(obj);
 	obs_data_set_string(obj, "source", GetWeakSourceName(_source).c_str());
-
+	_scene.Save(obj);
+	obs_data_set_int(obj, "sourceType", static_cast<int>(_sourceType));
 	obs_data_set_int(obj, "state", static_cast<int>(_state));
 	obs_data_set_int(obj, "restriction", static_cast<int>(_restriction));
 	_time.Save(obj);
+	obs_data_set_bool(obj, "matchOnChagne", _onlyMatchonChagne);
 	return true;
 }
 
+static bool enumSceneItem(obs_scene_t *, obs_sceneitem_t *item, void *ptr)
+{
+	auto *sources = reinterpret_cast<std::vector<OBSWeakSource> *>(ptr);
+
+	if (obs_sceneitem_is_group(item)) {
+		obs_scene_t *scene = obs_sceneitem_group_get_scene(item);
+		obs_scene_enum_items(scene, enumSceneItem, ptr);
+	}
+
+	auto source = obs_sceneitem_get_source(item);
+	std::string sourceId = obs_source_get_id(source);
+
+	if (sourceId.compare("ffmpeg_source") == 0 ||
+	    sourceId.compare("vlc_source") == 0) {
+		auto ws = obs_source_get_weak_source(source);
+		obs_weak_source_release(ws);
+		sources->emplace_back(ws);
+	}
+	return true;
+}
+
+void forMediaSourceOnSceneAddMediaCondition(
+	OBSWeakSource sceneWeakSource, MacroConditionMedia *origCond,
+	std::vector<MacroConditionMedia> &conditions)
+{
+	conditions.clear();
+	std::vector<OBSWeakSource> mediaSources;
+	auto s = obs_weak_source_get_source(sceneWeakSource);
+	auto scene = obs_scene_from_source(s);
+	obs_scene_enum_items(scene, enumSceneItem, &mediaSources);
+	obs_source_release(s);
+
+	for (auto &source : mediaSources) {
+		MacroConditionMedia cond(*origCond);
+		cond._sourceType = MediaSourceType::SOURCE;
+		cond._source = source;
+		conditions.push_back(cond);
+	}
+}
+
 bool MacroConditionMedia::Load(obs_data_t *obj)
 {
 	MacroCondition::Load(obj);
 	const char *sourceName = obs_data_get_string(obj, "source");
 	_source = GetWeakSourceByName(sourceName);
-
+	_scene.Load(obj);
+	_sourceType = static_cast<MediaSourceType>(
+		obs_data_get_int(obj, "sourceType"));
 	_state = static_cast<MediaState>(obs_data_get_int(obj, "state"));
 	_restriction = static_cast<MediaTimeRestriction>(
 		obs_data_get_int(obj, "restriction"));
 	_time.Load(obj);
+	if (!obs_data_has_user_value(obj, "matchOnChagne")) {
+		_onlyMatchonChagne = true;
+	} else {
+		_onlyMatchonChagne = obs_data_get_bool(obj, "matchOnChagne");
+	}
 
-	obs_source_t *mediasource = obs_weak_source_get_source(_source);
-	signal_handler_t *sh = obs_source_get_signal_handler(mediasource);
-	signal_handler_connect(sh, "media_stopped", MediaStopped, this);
-	signal_handler_connect(sh, "media_ended", MediaEnded, this);
-	obs_source_release(mediasource);
+	if (_sourceType == MediaSourceType::SOURCE) {
+		obs_source_t *mediasource = obs_weak_source_get_source(_source);
+		signal_handler_t *sh =
+			obs_source_get_signal_handler(mediasource);
+		signal_handler_connect(sh, "media_stopped", MediaStopped, this);
+		signal_handler_connect(sh, "media_ended", MediaEnded, this);
+		obs_source_release(mediasource);
+	}
+
+	forMediaSourceOnSceneAddMediaCondition(_scene.GetScene(), this,
+					       _sources);
 	return true;
 }
 
 std::string MacroConditionMedia::GetShortDesc()
 {
-	if (_source) {
-		return GetWeakSourceName(_source);
+	switch (_sourceType) {
+	case MediaSourceType::SOURCE:
+		if (_source) {
+			return GetWeakSourceName(_source);
+		}
+		break;
+	case MediaSourceType::ANY:
+		if (_scene.GetScene()) {
+			return obs_module_text(
+				       "AdvSceneSwitcher.condition.media.anyOnScene") +
+			       std::string(" ") + _scene.ToString();
+		}
+		break;
+	case MediaSourceType::ALL:
+		if (_scene.GetScene()) {
+			return obs_module_text(
+				       "AdvSceneSwitcher.condition.media.allOnScene") +
+			       std::string(" ") + _scene.ToString();
+		}
+		break;
+	default:
+		break;
 	}
 	return "";
 }
@@ -243,18 +344,33 @@ static void populateMediaStates(QComboBox *list)
 	}
 }
 
+static void addAnyAndAllStates(QComboBox *list)
+{
+	list->insertItem(
+		1,
+		obs_module_text("AdvSceneSwitcher.condition.media.anyOnScene"));
+	list->insertItem(
+		1,
+		obs_module_text("AdvSceneSwitcher.condition.media.allOnScene"));
+}
+
 MacroConditionMediaEdit::MacroConditionMediaEdit(
 	QWidget *parent, std::shared_ptr<MacroConditionMedia> entryData)
 	: QWidget(parent)
 {
 	_mediaSources = new QComboBox();
+	_scenes = new SceneSelectionWidget(window());
 	_states = new QComboBox();
 	_timeRestrictions = new QComboBox();
 	_time = new DurationSelection();
+	_onChange = new QCheckBox(obs_module_text(
+		"AdvSceneSwitcher.condition.media.matchOnChange"));
 
 	QWidget::connect(_mediaSources,
 			 SIGNAL(currentTextChanged(const QString &)), this,
 			 SLOT(SourceChanged(const QString &)));
+	QWidget::connect(_scenes, SIGNAL(SceneChanged(const SceneSelection &)),
+			 this, SLOT(SceneChanged(const SceneSelection &)));
 	QWidget::connect(_states, SIGNAL(currentIndexChanged(int)), this,
 			 SLOT(StateChanged(int)));
 	QWidget::connect(_timeRestrictions, SIGNAL(currentIndexChanged(int)),
@@ -263,20 +379,27 @@ MacroConditionMediaEdit::MacroConditionMediaEdit(
 			 SLOT(TimeChanged(double)));
 	QWidget::connect(_time, SIGNAL(UnitChanged(DurationUnit)), this,
 			 SLOT(TimeUnitChanged(DurationUnit)));
+	QWidget::connect(_onChange, SIGNAL(stateChanged(int)), this,
+			 SLOT(OnChangeChanged(int)));
 
 	populateMediaSelection(_mediaSources);
+	addAnyAndAllStates(_mediaSources);
 	populateMediaStates(_states);
 	populateMediaTimeRestrictions(_timeRestrictions);
 
-	QHBoxLayout *mainLayout = new QHBoxLayout;
+	QHBoxLayout *entryLayout = new QHBoxLayout;
 	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
 		{"{{mediaSources}}", _mediaSources},
+		{"{{scenes}}", _scenes},
 		{"{{states}}", _states},
 		{"{{timeRestrictions}}", _timeRestrictions},
 		{"{{time}}", _time},
 	};
 	placeWidgets(obs_module_text("AdvSceneSwitcher.condition.media.entry"),
-		     mainLayout, widgetPlaceholders);
+		     entryLayout, widgetPlaceholders);
+	QVBoxLayout *mainLayout = new QVBoxLayout;
+	mainLayout->addLayout(entryLayout);
+	mainLayout->addWidget(_onChange);
 	setLayout(mainLayout);
 
 	_entryData = entryData;
@@ -291,11 +414,41 @@ void MacroConditionMediaEdit::SourceChanged(const QString &text)
 	}
 
 	std::lock_guard<std::mutex> lock(switcher->m);
+
+	if (text ==
+	    obs_module_text("AdvSceneSwitcher.condition.media.anyOnScene")) {
+		_entryData->_sourceType = MediaSourceType::ANY;
+	} else if (text ==
+		   obs_module_text(
+			   "AdvSceneSwitcher.condition.media.allOnScene")) {
+		_entryData->_sourceType = MediaSourceType::ALL;
+	} else {
+		_entryData->_sources.clear();
+		_entryData->_sourceType = MediaSourceType::SOURCE;
+	}
+
 	_entryData->ClearSignalHandler();
 	_entryData->_source = GetWeakSourceByQString(text);
 	_entryData->ResetSignalHandler();
 	emit HeaderInfoChanged(
 		QString::fromStdString(_entryData->GetShortDesc()));
+
+	SetWidgetVisibility();
+}
+
+void MacroConditionMediaEdit::SceneChanged(const SceneSelection &s)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_scene = s;
+	forMediaSourceOnSceneAddMediaCondition(_entryData->_scene.GetScene(),
+					       _entryData.get(),
+					       _entryData->_sources);
+	emit HeaderInfoChanged(
+		QString::fromStdString(_entryData->GetShortDesc()));
 }
 
 MediaState getMediaStateFromIdx(int idx)
@@ -318,6 +471,11 @@ void MacroConditionMediaEdit::StateChanged(int index)
 
 	std::lock_guard<std::mutex> lock(switcher->m);
 	_entryData->_state = getMediaStateFromIdx(index);
+	if (_entryData->_sourceType != MediaSourceType::SOURCE) {
+		forMediaSourceOnSceneAddMediaCondition(
+			_entryData->_scene.GetScene(), _entryData.get(),
+			_entryData->_sources);
+	}
 }
 
 void MacroConditionMediaEdit::TimeRestrictionChanged(int index)
@@ -335,6 +493,11 @@ void MacroConditionMediaEdit::TimeRestrictionChanged(int index)
 
 	std::lock_guard<std::mutex> lock(switcher->m);
 	_entryData->_restriction = static_cast<MediaTimeRestriction>(index);
+	if (_entryData->_sourceType != MediaSourceType::SOURCE) {
+		forMediaSourceOnSceneAddMediaCondition(
+			_entryData->_scene.GetScene(), _entryData.get(),
+			_entryData->_sources);
+	}
 }
 
 void MacroConditionMediaEdit::TimeChanged(double seconds)
@@ -345,6 +508,11 @@ void MacroConditionMediaEdit::TimeChanged(double seconds)
 
 	std::lock_guard<std::mutex> lock(switcher->m);
 	_entryData->_time.seconds = seconds;
+	if (_entryData->_sourceType != MediaSourceType::SOURCE) {
+		forMediaSourceOnSceneAddMediaCondition(
+			_entryData->_scene.GetScene(), _entryData.get(),
+			_entryData->_sources);
+	}
 }
 
 void MacroConditionMediaEdit::TimeUnitChanged(DurationUnit unit)
@@ -355,6 +523,31 @@ void MacroConditionMediaEdit::TimeUnitChanged(DurationUnit unit)
 
 	std::lock_guard<std::mutex> lock(switcher->m);
 	_entryData->_time.displayUnit = unit;
+	if (_entryData->_sourceType != MediaSourceType::SOURCE) {
+		forMediaSourceOnSceneAddMediaCondition(
+			_entryData->_scene.GetScene(), _entryData.get(),
+			_entryData->_sources);
+	}
+}
+
+void MacroConditionMediaEdit::OnChangeChanged(int value)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_onlyMatchonChagne = value;
+	if (_entryData->_sourceType != MediaSourceType::SOURCE) {
+		forMediaSourceOnSceneAddMediaCondition(
+			_entryData->_scene.GetScene(), _entryData.get(),
+			_entryData->_sources);
+	}
+}
+
+void MacroConditionMediaEdit::SetWidgetVisibility()
+{
+	_scenes->setVisible(_entryData->_sourceType != MediaSourceType::SOURCE);
 }
 
 int getIdxFromMediaState(MediaState state)
@@ -373,8 +566,24 @@ void MacroConditionMediaEdit::UpdateEntryData()
 		return;
 	}
 
-	_mediaSources->setCurrentText(
-		GetWeakSourceName(_entryData->_source).c_str());
+	switch (_entryData->_sourceType) {
+	case MediaSourceType::ANY:
+		_mediaSources->setCurrentText(obs_module_text(
+			"AdvSceneSwitcher.condition.media.anyOnScene"));
+		break;
+	case MediaSourceType::ALL:
+		_mediaSources->setCurrentText(obs_module_text(
+			"AdvSceneSwitcher.condition.media.allOnScene"));
+		break;
+	case MediaSourceType::SOURCE:
+		_mediaSources->setCurrentText(
+			GetWeakSourceName(_entryData->_source).c_str());
+		break;
+	default:
+		break;
+	}
+
+	_scenes->SetScene(_entryData->_scene);
 	_states->setCurrentIndex(getIdxFromMediaState(_entryData->_state));
 	_timeRestrictions->setCurrentIndex(
 		static_cast<int>(_entryData->_restriction));
@@ -383,4 +592,6 @@ void MacroConditionMediaEdit::UpdateEntryData()
 	    MediaTimeRestriction::TIME_RESTRICTION_NONE) {
 		_time->setDisabled(true);
 	}
+	_onChange->setChecked(_entryData->_onlyMatchonChagne);
+	SetWidgetVisibility();
 }

src/macro-condition-plugin-state.cpp

@@ -9,16 +9,26 @@ bool MacroConditionPluginState::_registered = MacroConditionFactory::Register(
 	MacroConditionPluginState::id,
 	{MacroConditionPluginState::Create,
 	 MacroConditionPluginStateEdit::Create,
-	 "AdvSceneSwitcher.condition.pluginState", false});
+	 "AdvSceneSwitcher.condition.pluginState"});
 
 static std::map<PluginStateCondition, std::string> pluginStateConditionTypes = {
 	{PluginStateCondition::SCENESWITCHED,
 	 "AdvSceneSwitcher.condition.pluginState.state.sceneSwitched"},
+	{PluginStateCondition::RUNNING,
+	 "AdvSceneSwitcher.condition.pluginState.state.running"},
 };
 
 bool MacroConditionPluginState::CheckCondition()
 {
-	return switcher->macroSceneSwitched;
+	switch (_condition) {
+	case PluginStateCondition::SCENESWITCHED:
+		return switcher->macroSceneSwitched;
+	case PluginStateCondition::RUNNING:
+		return true;
+	default:
+		break;
+	}
+	return false;
 }
 
 bool MacroConditionPluginState::Save(obs_data_t *obj)

src/macro-condition-scene.cpp

@@ -158,7 +158,12 @@ void MacroConditionSceneEdit::SetWidgetVisibility()
 {
 	_scenes->setVisible(_entryData->_type == SceneType::CURRENT ||
 			    _entryData->_type == SceneType::PREVIOUS);
-	_waitForTransition->setVisible(_entryData->_type == SceneType::CURRENT);
+
+	// The waitForTransition option shall be slowly faded out over time and
+	// be replaced by the transition source and target scene checks
+	_waitForTransition->setVisible(_entryData->_type ==
+					       SceneType::CURRENT &&
+				       !_entryData->_waitForTransition);
 }
 
 void MacroConditionSceneEdit::UpdateEntryData()

src/macro-condition-timer.cpp

@@ -10,6 +10,11 @@ bool MacroConditionTimer::_registered = MacroConditionFactory::Register(
 	{MacroConditionTimer::Create, MacroConditionTimerEdit::Create,
 	 "AdvSceneSwitcher.condition.timer", false});
 
+static std::map<TimerType, std::string> timerTypes = {
+	{TimerType::FIXED, "AdvSceneSwitcher.condition.timer.type.fixed"},
+	{TimerType::RANDOM, "AdvSceneSwitcher.condition.timer.type.random"},
+};
+
 bool MacroConditionTimer::CheckCondition()
 {
 	if (_paused) {
@@ -18,16 +23,37 @@ bool MacroConditionTimer::CheckCondition()
 	if (_duration.DurationReached()) {
 		if (!_oneshot) {
 			_duration.Reset();
+			if (_type == TimerType::RANDOM) {
+				SetRandomTimeRemaining();
+			}
 		}
 		return true;
 	}
 	return false;
 }
 
+void MacroConditionTimer::SetRandomTimeRemaining()
+{
+	double min, max;
+	if (_duration.seconds <= _duration2.seconds) {
+		min = _duration.seconds;
+		max = _duration2.seconds;
+	} else {
+		min = _duration2.seconds;
+		max = _duration.seconds;
+	}
+	std::uniform_real_distribution<double> unif(min, max);
+
+	double remainingTime = unif(_re);
+	_duration.SetTimeRemaining(remainingTime);
+}
+
 bool MacroConditionTimer::Save(obs_data_t *obj)
 {
 	MacroCondition::Save(obj);
+	obs_data_set_int(obj, "type", static_cast<int>(_type));
 	_duration.Save(obj);
+	_duration2.Save(obj, "seconds2", "displayUnit2");
 	if (!_paused) {
 		_remaining = _duration.TimeRemaining();
 	}
@@ -45,7 +71,9 @@ bool MacroConditionTimer::Save(obs_data_t *obj)
 bool MacroConditionTimer::Load(obs_data_t *obj)
 {
 	MacroCondition::Load(obj);
+	_type = static_cast<TimerType>(obs_data_get_int(obj, "type"));
 	_duration.Load(obj);
+	_duration2.Load(obj, "seconds2", "displayUnit2");
 	_remaining = obs_data_get_double(obj, "remaining");
 	_paused = obs_data_get_bool(obj, "paused");
 	_saveRemaining = obs_data_get_bool(obj, "saveRemaining");
@@ -78,13 +106,25 @@ void MacroConditionTimer::Reset()
 {
 	_remaining = _duration.seconds;
 	_duration.Reset();
+	if (_type == TimerType::RANDOM) {
+		SetRandomTimeRemaining();
+	}
+}
+
+static inline void populateTimerTypeSelection(QComboBox *list)
+{
+	for (auto entry : timerTypes) {
+		list->addItem(obs_module_text(entry.second.c_str()));
+	}
 }
 
 MacroConditionTimerEdit::MacroConditionTimerEdit(
 	QWidget *parent, std::shared_ptr<MacroConditionTimer> entryData)
 	: QWidget(parent)
 {
+	_timerTypes = new QComboBox();
 	_duration = new DurationSelection();
+	_duration2 = new DurationSelection();
 	_autoReset = new QCheckBox();
 	_saveRemaining = new QCheckBox();
 	_pauseConinue = new QPushButton(
@@ -93,10 +133,18 @@ MacroConditionTimerEdit::MacroConditionTimerEdit(
 		obs_module_text("AdvSceneSwitcher.condition.timer.reset"));
 	_remaining = new QLabel();
 
+	populateTimerTypeSelection(_timerTypes);
+
+	QWidget::connect(_timerTypes, SIGNAL(currentIndexChanged(int)), this,
+			 SLOT(TimerTypeChanged(int)));
 	QWidget::connect(_duration, SIGNAL(DurationChanged(double)), this,
 			 SLOT(DurationChanged(double)));
 	QWidget::connect(_duration, SIGNAL(UnitChanged(DurationUnit)), this,
 			 SLOT(DurationUnitChanged(DurationUnit)));
+	QWidget::connect(_duration2, SIGNAL(DurationChanged(double)), this,
+			 SLOT(Duration2Changed(double)));
+	QWidget::connect(_duration2, SIGNAL(UnitChanged(DurationUnit)), this,
+			 SLOT(Duration2UnitChanged(DurationUnit)));
 	QWidget::connect(_pauseConinue, SIGNAL(clicked()), this,
 			 SLOT(PauseContinueClicked()));
 	QWidget::connect(_reset, SIGNAL(clicked()), this, SLOT(ResetClicked()));
@@ -105,9 +153,11 @@ MacroConditionTimerEdit::MacroConditionTimerEdit(
 	QWidget::connect(_saveRemaining, SIGNAL(stateChanged(int)), this,
 			 SLOT(SaveRemainingChanged(int)));
 
-	auto line1Layout = new QHBoxLayout;
+	_timerLayout = new QHBoxLayout;
 	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
+		{"{{type}}", _timerTypes},
 		{"{{duration}}", _duration},
+		{"{{duration2}}", _duration2},
 		{"{{autoReset}}", _autoReset},
 		{"{{remaining}}", _remaining},
 		{"{{pauseContinue}}", _pauseConinue},
@@ -115,8 +165,9 @@ MacroConditionTimerEdit::MacroConditionTimerEdit(
 		{"{{saveRemaining}}", _saveRemaining},
 	};
 	placeWidgets(
-		obs_module_text("AdvSceneSwitcher.condition.timer.entry.line1"),
-		line1Layout, widgetPlaceholders);
+		obs_module_text(
+			"AdvSceneSwitcher.condition.timer.entry.line1.fixed"),
+		_timerLayout, widgetPlaceholders);
 	auto line2Layout = new QHBoxLayout;
 	placeWidgets(
 		obs_module_text("AdvSceneSwitcher.condition.timer.entry.line2"),
@@ -127,7 +178,7 @@ MacroConditionTimerEdit::MacroConditionTimerEdit(
 		line3Layout, widgetPlaceholders);
 
 	auto *mainLayout = new QVBoxLayout;
-	mainLayout->addLayout(line1Layout);
+	mainLayout->addLayout(_timerLayout);
 	mainLayout->addLayout(line2Layout);
 	mainLayout->addLayout(line3Layout);
 	setLayout(mainLayout);
@@ -140,6 +191,17 @@ MacroConditionTimerEdit::MacroConditionTimerEdit(
 	timer.start(1000);
 }
 
+void MacroConditionTimerEdit::TimerTypeChanged(int type)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_type = static_cast<TimerType>(type);
+	SetWidgetVisibility();
+}
+
 void MacroConditionTimerEdit::DurationChanged(double seconds)
 {
 	if (_loading || !_entryData) {
@@ -160,6 +222,26 @@ void MacroConditionTimerEdit::DurationUnitChanged(DurationUnit unit)
 	_entryData->_duration.displayUnit = unit;
 }
 
+void MacroConditionTimerEdit::Duration2Changed(double seconds)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_duration2.seconds = seconds;
+}
+
+void MacroConditionTimerEdit::Duration2UnitChanged(DurationUnit unit)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_duration2.displayUnit = unit;
+}
+
 void MacroConditionTimerEdit::SaveRemainingChanged(int state)
 {
 	if (_loading || !_entryData) {
@@ -243,8 +325,44 @@ void MacroConditionTimerEdit::UpdateEntryData()
 		return;
 	}
 
+	_timerTypes->setCurrentIndex(static_cast<int>(_entryData->_type));
 	_duration->SetDuration(_entryData->_duration);
+	_duration2->SetDuration(_entryData->_duration2);
 	_autoReset->setChecked(!_entryData->_oneshot);
 	_saveRemaining->setChecked(_entryData->_saveRemaining);
 	SetPauseContinueButtonLabel();
+	SetWidgetVisibility();
+}
+
+void MacroConditionTimerEdit::SetWidgetVisibility()
+{
+	if (!_entryData) {
+		return;
+	}
+
+	_timerLayout->removeWidget(_timerTypes);
+	_timerLayout->removeWidget(_duration);
+	_timerLayout->removeWidget(_duration2);
+
+	clearLayout(_timerLayout);
+
+	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
+		{"{{type}}", _timerTypes},
+		{"{{duration}}", _duration},
+		{"{{duration2}}", _duration2},
+	};
+
+	if (_entryData->_type == TimerType::RANDOM) {
+		placeWidgets(
+			obs_module_text(
+				"AdvSceneSwitcher.condition.timer.entry.line1.random"),
+			_timerLayout, widgetPlaceholders);
+		_duration2->show();
+	} else {
+		placeWidgets(
+			obs_module_text(
+				"AdvSceneSwitcher.condition.timer.entry.line1.fixed"),
+			_timerLayout, widgetPlaceholders);
+		_duration2->hide();
+	}
 }

src/macro-condition-transition.cpp

@@ -19,6 +19,10 @@ static std::map<TransitionCondition, std::string> filterConditionTypes = {
 	 "AdvSceneSwitcher.condition.transition.type.started"},
 	{TransitionCondition::ENDED,
 	 "AdvSceneSwitcher.condition.transition.type.ended"},
+	{TransitionCondition::TRANSITION_SOURCE,
+	 "AdvSceneSwitcher.condition.transition.type.transitionSource"},
+	{TransitionCondition::TRANSITION_TARGET,
+	 "AdvSceneSwitcher.condition.transition.type.transitionTarget"},
 };
 
 bool isCurrentTransition(OBSWeakSource &t)
@@ -46,15 +50,26 @@ bool anySceneTransitionStarted()
 	return ret;
 }
 
+bool isTargetScene(OBSWeakSource &target)
+{
+	auto source = obs_frontend_get_current_scene();
+	auto targetScene = obs_source_get_weak_source(source);
+	bool ret = target == targetScene;
+	obs_weak_source_release(targetScene);
+	obs_source_release(source);
+	return ret;
+}
+
 bool MacroConditionTransition::CheckCondition()
 {
 	bool anyTransitionEnded = _lastTransitionEndTime !=
 				  switcher->lastTransitionEndTime;
+	bool anyTransitionStarted = anySceneTransitionStarted();
 	bool transitionStarted = false;
 	bool transitionEnded = false;
 
 	if (_transition.GetType() == TransitionSelectionType::ANY) {
-		transitionStarted = anySceneTransitionStarted();
+		transitionStarted = anyTransitionStarted;
 		transitionEnded = anyTransitionEnded;
 	} else {
 		transitionStarted = _started;
@@ -78,6 +93,15 @@ bool MacroConditionTransition::CheckCondition()
 	case TransitionCondition::ENDED:
 		ret = transitionEnded;
 		break;
+	case TransitionCondition::TRANSITION_SOURCE:
+		ret = anyTransitionStarted &&
+		      _scene.GetScene() == switcher->currentScene;
+		break;
+	case TransitionCondition::TRANSITION_TARGET: {
+		auto scene = _scene.GetScene();
+		ret = anyTransitionStarted && isTargetScene(scene);
+		break;
+	}
 	default:
 		break;
 	}
@@ -132,6 +156,7 @@ bool MacroConditionTransition::Save(obs_data_t *obj)
 	MacroCondition::Save(obj);
 	obs_data_set_int(obj, "condition", static_cast<int>(_condition));
 	_transition.Save(obj);
+	_scene.Save(obj);
 	_duration.Save(obj);
 	return true;
 }
@@ -142,6 +167,7 @@ bool MacroConditionTransition::Load(obs_data_t *obj)
 	_condition = static_cast<TransitionCondition>(
 		obs_data_get_int(obj, "condition"));
 	_transition.Load(obj);
+	_scene.Load(obj);
 	_duration.Load(obj);
 	ConnectToTransitionSignals();
 	return true;
@@ -149,7 +175,13 @@ bool MacroConditionTransition::Load(obs_data_t *obj)
 
 std::string MacroConditionTransition::GetShortDesc()
 {
-	return _transition.ToString();
+	if (_condition == TransitionCondition::CURRENT ||
+	    _condition == TransitionCondition::DURATION ||
+	    _condition == TransitionCondition::STARTED ||
+	    _condition == TransitionCondition::ENDED) {
+		return _transition.ToString();
+	}
+	return "";
 }
 
 static inline void populateConditionSelection(QComboBox *list)
@@ -165,6 +197,7 @@ MacroConditionTransitionEdit::MacroConditionTransitionEdit(
 {
 	_conditions = new QComboBox();
 	_transitions = new TransitionSelectionWidget(this, true, true);
+	_scenes = new SceneSelectionWidget(this, false, true, true);
 	_duration = new DurationSelection(this, false);
 	_durationSuffix = new QLabel(obs_module_text(
 		"AdvSceneSwitcher.condition.transition.durationSuffix"));
@@ -177,6 +210,8 @@ MacroConditionTransitionEdit::MacroConditionTransitionEdit(
 			 SIGNAL(TransitionChanged(const TransitionSelection &)),
 			 this,
 			 SLOT(TransitionChanged(const TransitionSelection &)));
+	QWidget::connect(_scenes, SIGNAL(SceneChanged(const SceneSelection &)),
+			 this, SLOT(SceneChanged(const SceneSelection &)));
 	QWidget::connect(_duration, SIGNAL(DurationChanged(double)), this,
 			 SLOT(DurationChanged(double)));
 
@@ -184,6 +219,7 @@ MacroConditionTransitionEdit::MacroConditionTransitionEdit(
 	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
 		{"{{conditions}}", _conditions},
 		{"{{transitions}}", _transitions},
+		{"{{scenes}}", _scenes},
 		{"{{duration}}", _duration},
 		{"{{durationSuffix}}", _durationSuffix},
 	};
@@ -228,6 +264,16 @@ void MacroConditionTransitionEdit::TransitionChanged(
 		QString::fromStdString(_entryData->GetShortDesc()));
 }
 
+void MacroConditionTransitionEdit::SceneChanged(const SceneSelection &s)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_scene = s;
+}
+
 void MacroConditionTransitionEdit::DurationChanged(double seconds)
 {
 	if (_loading || !_entryData) {
@@ -248,6 +294,10 @@ void MacroConditionTransitionEdit::SetWidgetVisibility()
 		_entryData->_condition == TransitionCondition::CURRENT ||
 		_entryData->_condition == TransitionCondition::STARTED ||
 		_entryData->_condition == TransitionCondition::ENDED);
+	_scenes->setVisible(_entryData->_condition ==
+				    TransitionCondition::TRANSITION_SOURCE ||
+			    _entryData->_condition ==
+				    TransitionCondition::TRANSITION_TARGET);
 	_duration->setVisible(_entryData->_condition ==
 			      TransitionCondition::DURATION);
 	_durationSuffix->setVisible(_entryData->_condition ==
@@ -268,5 +318,6 @@ void MacroConditionTransitionEdit::UpdateEntryData()
 	SetWidgetVisibility();
 	_conditions->setCurrentIndex(static_cast<int>(_entryData->_condition));
 	_transitions->SetTransition(_entryData->_transition);
+	_scenes->SetScene(_entryData->_scene);
 	_duration->SetDuration(_entryData->_duration);
 }

src/macro-tab.cpp

@@ -82,7 +82,7 @@ void AdvSceneSwitcher::on_macroRemove_clicked()
 	{
 		std::lock_guard<std::mutex> lock(switcher->m);
 		switcher->abortMacroWait = true;
-		switcher->macroWaitCv.notify_one();
+		switcher->macroWaitCv.notify_all();
 		int idx = ui->macros->currentRow();
 		QString::fromStdString(switcher->macros[idx]->Name());
 		switcher->macros.erase(switcher->macros.begin() + idx);
@@ -173,6 +173,31 @@ void AdvSceneSwitcher::on_macroName_editingFinished()
 	emit MacroRenamed(oldName, newName);
 }
 
+void AdvSceneSwitcher::on_runMacro_clicked()
+{
+	Macro *macro = getSelectedMacro();
+	if (!macro) {
+		return;
+	}
+
+	bool ret = macro->PerformAction(true);
+	if (!ret) {
+		QString err =
+			obs_module_text("AdvSceneSwitcher.macroTab.runFail");
+		DisplayMessage(err.arg(QString::fromStdString(macro->Name())));
+	}
+}
+
+void AdvSceneSwitcher::on_runMacroInParallel_stateChanged(int value)
+{
+	Macro *macro = getSelectedMacro();
+	if (!macro) {
+		return;
+	}
+	std::lock_guard<std::mutex> lock(switcher->m);
+	macro->SetRunInParallel(value);
+}
+
 void AdvSceneSwitcher::PopulateMacroActions(Macro &m, uint32_t afterIdx)
 {
 	auto &actions = m.Actions();
@@ -205,6 +230,7 @@ void AdvSceneSwitcher::PopulateMacroConditions(Macro &m, uint32_t afterIdx)
 void AdvSceneSwitcher::SetEditMacro(Macro &m)
 {
 	ui->macroName->setText(m.Name().c_str());
+	ui->runMacroInParallel->setChecked(m.RunInParallel());
 	clearLayout(ui->macroEditConditionLayout);
 	clearLayout(ui->macroEditActionLayout);
 
@@ -347,6 +373,9 @@ void AdvSceneSwitcher::setupMacroTab()
 		&AdvSceneSwitcher::ShowMacroConditionsContextMenu);
 
 	ui->macroEdit->setDisabled(true);
+
+	ui->macroPriorityWarning->setVisible(
+		switcher->functionNamesByPriority[0] != macro_func);
 }
 
 void AdvSceneSwitcher::ShowMacroContextMenu(const QPoint &pos)

src/macro.cpp

@@ -29,6 +29,10 @@ Macro::Macro(const std::string &name)
 
 Macro::~Macro()
 {
+	_stop = true;
+	if (_thread.joinable()) {
+		_thread.join();
+	}
 	ClearHotkeys();
 }
 
@@ -104,15 +108,22 @@ bool Macro::CeckMatch()
 	return _matched;
 }
 
-bool Macro::PerformAction()
+bool Macro::PerformAction(bool forceParallel)
 {
+	if (!_done) {
+		vblog(LOG_INFO, "macro %s already running", _name.c_str());
+		return false;
+	}
+
 	bool ret = true;
-	for (auto &a : _actions) {
-		a->LogAction();
-		ret = ret && a->PerformAction();
-		if (!ret) {
-			return false;
+	_done = false;
+	if (_runInParallel || forceParallel) {
+		if (_thread.joinable()) {
+			_thread.join();
 		}
+		_thread = std::thread([this] { RunActions(); });
+	} else {
+		RunActions(ret);
 	}
 	return ret;
 }
@@ -130,6 +141,27 @@ void Macro::ResetTimers()
 	}
 }
 
+void Macro::RunActions(bool &retVal)
+{
+	bool ret = true;
+	for (auto &a : _actions) {
+		a->LogAction();
+		ret = ret && a->PerformAction();
+		if (!ret || _stop) {
+			retVal = ret;
+			_done = true;
+			return;
+		}
+	}
+	_done = true;
+}
+
+void Macro::RunActions()
+{
+	bool unused;
+	RunActions(unused);
+}
+
 void Macro::SetPaused(bool pause)
 {
 	if (_paused && !pause) {
@@ -160,6 +192,7 @@ bool Macro::Save(obs_data_t *obj)
 {
 	obs_data_set_string(obj, "name", _name.c_str());
 	obs_data_set_bool(obj, "pause", _paused);
+	obs_data_set_bool(obj, "parallel", _runInParallel);
 
 	obs_data_array_t *pauseHotkey = obs_hotkey_save(_pauseHotkey);
 	obs_data_set_array(obj, "pauseHotkey", pauseHotkey);
@@ -167,6 +200,10 @@ bool Macro::Save(obs_data_t *obj)
 	obs_data_array_t *unpauseHotkey = obs_hotkey_save(_unpauseHotkey);
 	obs_data_set_array(obj, "unpauseHotkey", unpauseHotkey);
 	obs_data_array_release(unpauseHotkey);
+	obs_data_array_t *togglePauseHotkey =
+		obs_hotkey_save(_togglePauseHotkey);
+	obs_data_set_array(obj, "togglePauseHotkey", togglePauseHotkey);
+	obs_data_array_release(togglePauseHotkey);
 
 	obs_data_array_t *conditions = obs_data_array_create();
 	for (auto &c : _conditions) {
@@ -233,15 +270,19 @@ bool Macro::Load(obs_data_t *obj)
 {
 	_name = obs_data_get_string(obj, "name");
 	_paused = obs_data_get_bool(obj, "pause");
+	_runInParallel = obs_data_get_bool(obj, "parallel");
 
 	obs_data_array_t *pauseHotkey = obs_data_get_array(obj, "pauseHotkey");
 	obs_hotkey_load(_pauseHotkey, pauseHotkey);
 	obs_data_array_release(pauseHotkey);
-
 	obs_data_array_t *unpauseHotkey =
 		obs_data_get_array(obj, "unpauseHotkey");
 	obs_hotkey_load(_unpauseHotkey, unpauseHotkey);
 	obs_data_array_release(unpauseHotkey);
+	obs_data_array_t *togglePauseHotkey =
+		obs_data_get_array(obj, "togglePauseHotkey");
+	obs_hotkey_load(_togglePauseHotkey, togglePauseHotkey);
+	obs_data_array_release(togglePauseHotkey);
 
 	SetHotkeysDesc();
 
@@ -331,75 +372,90 @@ bool Macro::SwitchesScene()
 	return false;
 }
 
-static void pauseCB(void *data, obs_hotkey_id id, obs_hotkey_t *hotkey,
-		    bool pressed)
+static void pauseCB(void *data, obs_hotkey_id, obs_hotkey_t *, bool pressed)
 {
-	UNUSED_PARAMETER(id);
-	UNUSED_PARAMETER(data);
-	UNUSED_PARAMETER(hotkey);
 	if (pressed) {
 		auto m = static_cast<Macro *>(data);
 		m->SetPaused(true);
 	}
 }
 
-static void unpauseCB(void *data, obs_hotkey_id id, obs_hotkey_t *hotkey,
-		      bool pressed)
+static void unpauseCB(void *data, obs_hotkey_id, obs_hotkey_t *, bool pressed)
 {
-	UNUSED_PARAMETER(id);
-	UNUSED_PARAMETER(data);
-	UNUSED_PARAMETER(hotkey);
 	if (pressed) {
 		auto m = static_cast<Macro *>(data);
 		m->SetPaused(false);
 	}
 }
 
+static void togglePauseCB(void *data, obs_hotkey_id, obs_hotkey_t *,
+			  bool pressed)
+{
+	if (pressed) {
+		auto m = static_cast<Macro *>(data);
+		m->SetPaused(!m->Paused());
+	}
+}
+
 static int macroHotkeyID = 0;
 
+obs_hotkey_id registerHotkeyHelper(const std::string prefix,
+				   const char *formatModuleText, Macro *macro,
+				   obs_hotkey_func func)
+{
+	macroHotkeyID++;
+
+	std::string hotkeyName = prefix + std::to_string(macroHotkeyID);
+	QString format{obs_module_text(formatModuleText)};
+	QString hotkeyDesc = format.arg(QString::fromStdString(macro->Name()));
+	return obs_hotkey_register_frontend(hotkeyName.c_str(),
+					    hotkeyDesc.toStdString().c_str(),
+					    func, macro);
+}
+
 void Macro::SetupHotkeys()
 {
 	if (_pauseHotkey != OBS_INVALID_HOTKEY_ID ||
-	    _unpauseHotkey != OBS_INVALID_HOTKEY_ID) {
+	    _unpauseHotkey != OBS_INVALID_HOTKEY_ID ||
+	    _togglePauseHotkey != OBS_INVALID_HOTKEY_ID) {
 		ClearHotkeys();
 	}
 
-	macroHotkeyID++;
-
-	std::string hotkeyName =
-		"macro_pause_hotkey_" + std::to_string(macroHotkeyID);
-	QString format{obs_module_text("AdvSceneSwitcher.hotkey.macro.pause")};
-	QString hotkeyDesc = format.arg(QString::fromStdString(_name));
-	_pauseHotkey = obs_hotkey_register_frontend(
-		hotkeyName.c_str(), hotkeyDesc.toStdString().c_str(), pauseCB,
-		this);
-
-	macroHotkeyID++;
-
-	hotkeyName = "macro_pause_hotkey_" + _name;
-	format = {obs_module_text("AdvSceneSwitcher.hotkey.macro.unpause")};
-	hotkeyDesc = format.arg(QString::fromStdString(_name));
-	_unpauseHotkey = obs_hotkey_register_frontend(
-		hotkeyName.c_str(), hotkeyDesc.toStdString().c_str(), unpauseCB,
-		this);
+	_pauseHotkey = registerHotkeyHelper(
+		"macro_pause_hotkey_", "AdvSceneSwitcher.hotkey.macro.pause",
+		this, pauseCB);
+	_unpauseHotkey = registerHotkeyHelper(
+		"macro_unpause_hotkey_",
+		"AdvSceneSwitcher.hotkey.macro.unpause", this, unpauseCB);
+	_togglePauseHotkey = registerHotkeyHelper(
+		"macro_toggle_pause_hotkey_",
+		"AdvSceneSwitcher.hotkey.macro.togglePause", this,
+		togglePauseCB);
 }
 
 void Macro::ClearHotkeys()
 {
 	obs_hotkey_unregister(_pauseHotkey);
 	obs_hotkey_unregister(_unpauseHotkey);
+	obs_hotkey_unregister(_togglePauseHotkey);
+}
+
+void setHotkeyDescriptionHelper(const char *formatModuleText,
+				const std::string name, const obs_hotkey_id id)
+{
+	QString format{obs_module_text(formatModuleText)};
+	QString hotkeyDesc = format.arg(QString::fromStdString(name));
+	obs_hotkey_set_description(id, hotkeyDesc.toStdString().c_str());
 }
 
 void Macro::SetHotkeysDesc()
 {
-	QString format{obs_module_text("AdvSceneSwitcher.hotkey.macro.pause")};
-	QString hotkeyDesc = format.arg(QString::fromStdString(_name));
-	obs_hotkey_set_description(_pauseHotkey,
-				   hotkeyDesc.toStdString().c_str());
-	format = {obs_module_text("AdvSceneSwitcher.hotkey.macro.unpause")};
-	hotkeyDesc = format.arg(QString::fromStdString(_name));
-	obs_hotkey_set_description(_unpauseHotkey,
-				   hotkeyDesc.toStdString().c_str());
+	setHotkeyDescriptionHelper("AdvSceneSwitcher.hotkey.macro.pause", _name,
+				   _pauseHotkey);
+	setHotkeyDescriptionHelper("AdvSceneSwitcher.hotkey.macro.unpause",
+				   _name, _unpauseHotkey);
+	setHotkeyDescriptionHelper("AdvSceneSwitcher.hotkey.macro.togglePause",
+				   _name, _togglePauseHotkey);
 }
 
 bool MacroCondition::Save(obs_data_t *obj)
@@ -519,7 +575,6 @@ bool SwitcherData::runMacros()
 			if (!m->PerformAction()) {
 				blog(LOG_WARNING, "abort macro: %s",
 				     m->Name().c_str());
-				return false;
 			}
 		}
 	}

src/switch-audio.cpp

@@ -347,7 +347,7 @@ AudioSwitch::AudioSwitch(const AudioSwitch &other)
 	volmeter = AddVolmeterToSource(this, other.audioSource);
 }
 
-AudioSwitch::AudioSwitch(AudioSwitch &&other)
+AudioSwitch::AudioSwitch(AudioSwitch &&other) noexcept
 	: SceneSwitcherEntry(other.targetType, other.group, other.scene,
 			     other.transition, other.usePreviousScene),
 	  audioSource(other.audioSource),

src/switch-media.cpp

@@ -342,7 +342,7 @@ MediaSwitch::MediaSwitch(const MediaSwitch &other)
 	obs_source_release(mediasource);
 }
 
-MediaSwitch::MediaSwitch(MediaSwitch &&other)
+MediaSwitch::MediaSwitch(MediaSwitch &&other) noexcept
 	: SceneSwitcherEntry(other.targetType, other.group, other.scene,
 			     other.transition, other.usePreviousScene),
 	  source(other.source),

src/switch-priority.cpp

@@ -33,6 +33,8 @@ void AdvSceneSwitcher::on_priorityUp_clicked()
 			  switcher->functionNamesByPriority.begin() +
 				  currentIndex - 1);
 	}
+	ui->macroPriorityWarning->setVisible(
+		switcher->functionNamesByPriority[0] != macro_func);
 }
 
 void AdvSceneSwitcher::on_priorityDown_clicked()
@@ -51,6 +53,8 @@ void AdvSceneSwitcher::on_priorityDown_clicked()
 			  switcher->functionNamesByPriority.begin() +
 				  currentIndex + 1);
 	}
+	ui->macroPriorityWarning->setVisible(
+		switcher->functionNamesByPriority[0] != macro_func);
 }
 
 bool SwitcherData::prioFuncsValid()

src/utility.cpp

@@ -217,7 +217,7 @@ void deleteLayoutItem(QLayoutItem *item)
 void clearLayout(QLayout *layout, int afterIdx)
 {
 	QLayoutItem *item;
-	while (item = layout->takeAt(afterIdx)) {
+	while ((item = layout->takeAt(afterIdx))) {
 		if (item->layout()) {
 			clearLayout(item->layout());
 			delete item->layout();
@@ -594,7 +594,7 @@ void populateAudioSelection(QComboBox *sel, bool addSelect)
 	sel->setCurrentIndex(0);
 }
 
-void populateVideoSelection(QComboBox *sel, bool addSelect)
+void populateVideoSelection(QComboBox *sel, bool addScenes, bool addSelect)
 {
 
 	auto sourceEnum = [](void *data, obs_source_t *source) -> bool /* -- */
@@ -616,6 +616,11 @@ void populateVideoSelection(QComboBox *sel, bool addSelect)
 		sel->addItem(source.c_str());
 	}
 
+	if (addScenes) {
+		populateSceneSelection(sel, false, false, false, false, nullptr,
+				       false);
+	}
+
 	sel->model()->sort(0);
 	if (addSelect) {
 		addSelectionEntry(
@@ -962,3 +967,14 @@ bool listMoveDown(QListWidget *list)
 	list->setCurrentRow(index + 1);
 	return true;
 }
+
+void setHeightToContentHeight(QListWidget *list)
+{
+	auto nrItems = list->count();
+	if (nrItems == 0) {
+		list->setMaximumHeight(0);
+	} else {
+		list->setMaximumHeight(list->sizeHintForRow(0) * nrItems +
+				       2 * list->frameWidth());
+	}
+}