CI: Switch to OBS 27.1.3

This should be expanded upon by adding the ability to add weights to each macro.

.github/workflows/build-debian.yml

@@ -43,7 +43,7 @@ jobs:
            # devscripts and libobs-dev are needed but they were already installed
            # from check_libobs_revision and install_frontend_header sections.
            sudo apt update
-           sudo apt install cmake debhelper libcurl4-openssl-dev libxss-dev libxtst-dev qtbase5-dev libopencv-dev
+           sudo apt install cmake debhelper libcurl4-openssl-dev libxss-dev libxtst-dev qtbase5-dev libopencv-dev libprocps-dev
     - name: build
       run: |
            debuild --no-lintian --no-sign

.github/workflows/build.yml

@@ -1,15 +1,11 @@
 name: build obs plugin
 
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    branches: [ master ]
+on: [push, pull_request, workflow_dispatch]
 
 env:
   PLUGIN_NAME: SceneSwitcher
   LIB_NAME: advanced-scene-switcher
-  OBS_TAG: 27.1.1
+  OBS_TAG: 27.1.3
 
 jobs:
   macos64:
@@ -183,7 +179,8 @@ jobs:
            libxss-dev \
            libx11-xcb-dev \
            libxcb-xfixes0-dev \
-           libopencv-dev
+           libopencv-dev \
+           libprocps-dev
       - name: 'Configure'
         shell: bash
         run: |

CI/release/README.txt

@@ -1,4 +1,4 @@
-Note that you will have to use OBS version 26.1 or newer!
+Note that you will have to use OBS version 27 or newer!
 
 --- Windows ---
 Recommended: Run the provided installer. (You might have to click 'More info' and select 'Run anyway' if it is blocked by Windows)
@@ -8,17 +8,17 @@ It is usually located at 'C:\Program Files (x86)\obs-studio\'.
 Remember to install the Visual C++ Redistributable for Visual Studio 2019, if you have not done so already. (See plugin overview page)
 
 --- macOS ---
-Recommended: Run the provided installer. (You might have to right-click or control-click and select 'open' if it is blocked)
-
-Alternatively extract the *so file and data folder and either ...
-
-... right-click the OBS app inside your Applications folder and choose 'Show Package Contents'.
-Copy the advanced-scene-switcher.so file to 'Contents/Plugins' and the 'data' folder to 'Contents/Resources'.
-
-... or copy the advanced-scene-switcher.so file to Library/Application Support/obs-studio/plugins/advanced-scene-switcher/bin/ .
-And the 'data' folder to 'Library/Application Support/obs-studio/plugins/advanced-scene-switcher/'.
+Run the provided installer. (You might have to right-click or control-click and select 'open' if it is blocked)
 
 --- Linux ---
+Note that the plugin has dependencies to:
+ * libXss
+ * libopencv-imgproc
+ * libopencv-objdetect
+Optional:
+ * libXtst
+ * libcurl
+
 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.
 

CMakeLists.txt

@@ -137,9 +137,19 @@ endif()
 
 if(UNIX AND NOT APPLE)
   find_package(X11 REQUIRED COMPONENTS Xtst Xss)
-  link_libraries(${X11_LIBRARIES})
+  find_path(PROCPS_INCLUDE_DIR NAMES proc/procps.h)
+  if(NOT PROCPS_INCLUDE_DIR)
+    message(
+      FATAL_ERROR "procps include dir not found - please set PROCPS_INCLUDE_DIR"
+    )
+  endif()
+  find_library(PROCPS_LIBRARY NAMES procps)
+  if(NOT PROCPS_LIBRARY)
+    message(FATAL_ERROR "procps lib not found - please set PROCPS_LIBRARY")
+  endif()
+  link_libraries(${X11_LIBRARIES} ${procps_LIBRARIES})
   include_directories("${X11_INCLUDE_DIR}" "${X11_Xtst_INCLUDE_PATH}"
-                      "${X11_Xss_INCLUDE_PATH}")
+                      "${X11_Xss_INCLUDE_PATH}" "${PROCPS_INCLUDE_DIR}")
 endif()
 
 if(WIN32)
@@ -154,7 +164,7 @@ elseif(APPLE)
 else()
   set(advanced-scene-switcher_PLATFORM_SOURCES
       src/linux/advanced-scene-switcher-nix.cpp)
-  set(advanced-scene-switcher_PLATFORM_LIBS Xss)
+  set(advanced-scene-switcher_PLATFORM_LIBS Xss ${PROCPS_LIBRARY})
 endif()
 
 # asio and websocketpp
@@ -165,10 +175,6 @@ if(WIN32)
   add_definitions(-D_WEBSOCKETPP_CPP11_STL_)
 endif()
 
-# opencv
-find_package(OpenCV REQUIRED)
-include_directories("${OpenCV_INCLUDE_DIRS}")
-
 # Setup QT tools
 set(CMAKE_AUTOMOC ON)
 set(CMAKE_AUTOUIC ON)
@@ -209,6 +215,7 @@ set(advanced-scene-switcher_HEADERS
     src/headers/macro-action-media.hpp
     src/headers/macro-action-plugin-state.hpp
     src/headers/macro-action-preview-scene.hpp
+    src/headers/macro-action-random.hpp
     src/headers/macro-action-recording.hpp
     src/headers/macro-action-replay-buffer.hpp
     src/headers/macro-action-run.hpp
@@ -239,6 +246,7 @@ set(advanced-scene-switcher_HEADERS
     src/headers/macro-condition-replay-buffer.hpp
     src/headers/macro-condition-scene-order.hpp
     src/headers/macro-condition-scene-transform.hpp
+    src/headers/macro-condition-scene-visibility.hpp
     src/headers/macro-condition-scene.hpp
     src/headers/macro-condition-source.hpp
     src/headers/macro-condition-streaming.hpp
@@ -300,6 +308,7 @@ set(advanced-scene-switcher_SOURCES
     src/macro-action-media.cpp
     src/macro-action-plugin-state.cpp
     src/macro-action-preview-scene.cpp
+    src/macro-action-random.cpp
     src/macro-action-recording.cpp
     src/macro-action-replay-buffer.cpp
     src/macro-action-run.cpp
@@ -330,6 +339,7 @@ set(advanced-scene-switcher_SOURCES
     src/macro-condition-replay-buffer.cpp
     src/macro-condition-scene-order.cpp
     src/macro-condition-scene-transform.cpp
+    src/macro-condition-scene-visibility.cpp
     src/macro-condition-scene.cpp
     src/macro-condition-source.cpp
     src/macro-condition-streaming.cpp
@@ -354,6 +364,22 @@ set(advanced-scene-switcher_SOURCES
     src/volume-control.cpp
     src/version.cpp)
 
+# opencv
+find_package(OpenCV)
+if(OpenCV_FOUND)
+  include_directories("${OpenCV_INCLUDE_DIRS}")
+else()
+  set(OpenCV_LIBRARIES "")
+  message(
+    WARNING
+      "OpenCV not found! Functionality relying on OpenCV will be disabled!\nOpenCV sources are available under: ${CMAKE_CURRENT_SOURCE_DIR}/deps/opencv"
+  )
+  list(REMOVE_ITEM advanced-scene-switcher_SOURCES
+       src/macro-condition-video.cpp)
+  list(REMOVE_ITEM advanced-scene-switcher_HEADERS
+       src/headers/macro-condition-video.hpp)
+endif()
+
 add_library(
   advanced-scene-switcher MODULE
   ${advanced-scene-switcher_HEADERS}
@@ -401,11 +427,7 @@ if(BUILD_OUT_OF_TREE)
 else()
   # In tree build
   target_link_libraries(
-    advanced-scene-switcher
-    ${advanced-scene-switcher_PLATFORM_LIBS}
-    ${OpenCV_LIBRARIES}
-    obs-frontend-api
-    Qt5::Widgets
-    libobs)
+    advanced-scene-switcher ${advanced-scene-switcher_PLATFORM_LIBS}
+    ${OpenCV_LIBRARIES} obs-frontend-api Qt5::Widgets libobs)
   install_obs_plugin_with_data(advanced-scene-switcher data)
 endif()

data/locale/de-DE.ini

@@ -45,7 +45,7 @@ AdvSceneSwitcher.generalTab.priority.fileContent="Datei Inhalt"
 AdvSceneSwitcher.generalTab.priority.sceneSequence="Szenenfolge"
 AdvSceneSwitcher.generalTab.priority.idleDetection="Inaktivitätserkennung"
 AdvSceneSwitcher.generalTab.priority.executable="Prozess"
-AdvSceneSwitcher.generalTab.priority.screenRegion="Bildschrimbereich"
+AdvSceneSwitcher.generalTab.priority.screenRegion="Bildschirmbereich"
 AdvSceneSwitcher.generalTab.priority.windowTitle="Fenstername"
 AdvSceneSwitcher.generalTab.priority.media="Medien"
 AdvSceneSwitcher.generalTab.priority.time="Zeit"
@@ -98,7 +98,7 @@ AdvSceneSwitcher.executableTab.entry="Wenn {{processes}} läuft wechsle zu {{sce
 AdvSceneSwitcher.executableTab.help="Dieser Tab erlaubt es Szenen zu wechseln, wenn bestimmte Prozesse laufen.\nDas kann nützlich sein, wenn sich der Name eines Fensters ändern kann oder dieser nicht bekannt ist.\n\nKlicke auf das markierte Plus Symbol, um einen neuen Eintrag hinzuzufügen."
 
 ; Screen Region Tab
-AdvSceneSwitcher.screenRegionTab.title="Bildschrimbereich"
+AdvSceneSwitcher.screenRegionTab.title="Bildschirmbereich"
 AdvSceneSwitcher.screenRegionTab.currentPosition="Mauszeiger ist bei:"
 AdvSceneSwitcher.screenRegionTab.showGuideFrames="Hilfsrahmen einblenden"
 AdvSceneSwitcher.screenRegionTab.hideGuideFrames="Hilfsrahmen ausblenden"

data/locale/en-US.ini

@@ -28,6 +28,7 @@ AdvSceneSwitcher.generalTab.generalBehavior.cooldown="After a match do not switc
 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"
+AdvSceneSwitcher.generalTab.generalBehavior.showTrayNotifications="Show system tray notifications"
 AdvSceneSwitcher.generalTab.generalBehavior.disableUIHints="Disable UI hints"
 AdvSceneSwitcher.generalTab.priority="Priority"
 AdvSceneSwitcher.generalTab.priority.description="Switching methods priority (Highest priority is at the top)"
@@ -95,7 +96,7 @@ AdvSceneSwitcher.condition.cursor.entry.line2="Cursor is currently at {{xPos}} x
 AdvSceneSwitcher.condition.scene="Scene"
 AdvSceneSwitcher.condition.scene.type.current="Current scene is"
 AdvSceneSwitcher.condition.scene.type.previous="Previous scene is"
-AdvSceneSwitcher.condition.scene.type.changed="Scene chagned"
+AdvSceneSwitcher.condition.scene.type.changed="Scene changed"
 AdvSceneSwitcher.condition.scene.type.notChanged="Scene has not changed"
 AdvSceneSwitcher.condition.scene.waitForTransition="Wait for transition to complete"
 AdvSceneSwitcher.condition.scene.entry="{{sceneType}} {{scenes}} {{waitForTransition}}"
@@ -119,6 +120,8 @@ AdvSceneSwitcher.condition.video.condition.object="contains object"
 AdvSceneSwitcher.condition.video.askFileAction="Do you want to use an existing file or create a screenshot of the currently selected source?"
 AdvSceneSwitcher.condition.video.askFileAction.file="Use existing file"
 AdvSceneSwitcher.condition.video.askFileAction.screenshot="Create screenshot"
+AdvSceneSwitcher.condition.video.usePatternForChangedCheck="Use pattern matching"
+AdvSceneSwitcher.condition.video.usePatternForChangedCheck.tooltip="This will allow you to control how much the image has to change for the condition to be true."
 AdvSceneSwitcher.condition.video.patternThreshold="Threshold: "
 AdvSceneSwitcher.condition.video.patternThresholdDescription="A higher threshold value means that the pattern needs to match the video source more closely."
 AdvSceneSwitcher.condition.video.patternThresholdUseAlphaAsMask="Use alpha channel as mask for pattern."
@@ -139,6 +142,8 @@ AdvSceneSwitcher.condition.video.entry.throttle="{{throttleEnable}}Reduce CPU lo
 AdvSceneSwitcher.condition.stream="Streaming"
 AdvSceneSwitcher.condition.stream.state.start="Stream running"
 AdvSceneSwitcher.condition.stream.state.stop="Stream stopped"
+AdvSceneSwitcher.condition.stream.state.starting="Stream starting"
+AdvSceneSwitcher.condition.stream.state.stopping="Stream stopping"
 AdvSceneSwitcher.condition.stream.entry="{{streamState}}"
 AdvSceneSwitcher.condition.record="Recording"
 AdvSceneSwitcher.condition.record.state.start="Recording running"
@@ -167,6 +172,7 @@ AdvSceneSwitcher.condition.macro.count.type.below="Less than"
 AdvSceneSwitcher.condition.macro.count.type.above="More than"
 AdvSceneSwitcher.condition.macro.count.type.equal="Exactly"
 AdvSceneSwitcher.condition.macro.count.reset="Reset"
+AdvSceneSwitcher.condition.macro.pausedWarning="Selected macro is currently paused!"
 AdvSceneSwitcher.condition.macro.state.entry="Conditions of {{macros}} are true"
 AdvSceneSwitcher.condition.macro.count.entry.line1="{{macros}} was executed {{conditions}} {{count}} times"
 AdvSceneSwitcher.condition.macro.count.entry.line2="Current count: {{currentCount}} {{resetCount}}"
@@ -227,6 +233,10 @@ AdvSceneSwitcher.condition.transition.type.started="Transition active"
 AdvSceneSwitcher.condition.transition.type.ended="Transition ended"
 AdvSceneSwitcher.condition.transition.durationSuffix="seconds"
 AdvSceneSwitcher.condition.transition.entry="{{conditions}}{{transitions}}{{duration}}{{durationSuffix}}"
+AdvSceneSwitcher.condition.sceneVisibility="Scene item visibility"
+AdvSceneSwitcher.condition.sceneVisibility.type.shown="Shown"
+AdvSceneSwitcher.condition.sceneVisibility.type.hidden="Hidden"
+AdvSceneSwitcher.condition.sceneVisibility.entry="On {{scenes}} {{sources}} is {{conditions}} "
 
 ; Macro Actions
 AdvSceneSwitcher.action.switchScene="Switch scene"
@@ -241,6 +251,7 @@ AdvSceneSwitcher.action.audio.type.mute="Mute"
 AdvSceneSwitcher.action.audio.type.unmute="Unmute"
 AdvSceneSwitcher.action.audio.type.sourceVolume="Set source volume"
 AdvSceneSwitcher.action.audio.type.masterVolume="Set master volume"
+AdvSceneSwitcher.action.audio.fade="{{fade}}Fade over {{duration}} seconds"
 AdvSceneSwitcher.action.audio.entry="{{actions}} {{audioSources}} {{volume}}"
 AdvSceneSwitcher.action.recording="Recording"
 AdvSceneSwitcher.action.recording.type.stop="Stop recording"
@@ -266,7 +277,9 @@ AdvSceneSwitcher.action.run.entry="Run {{filePath}}"
 AdvSceneSwitcher.action.sceneVisibility="Scene item visibility"
 AdvSceneSwitcher.action.sceneVisibility.type.show="Show"
 AdvSceneSwitcher.action.sceneVisibility.type.hide="Hide"
-AdvSceneSwitcher.action.sceneVisibility.entry="On {{scenes}} {{actions}} {{sources}}"
+AdvSceneSwitcher.action.sceneVisibility.type.source="Source"
+AdvSceneSwitcher.action.sceneVisibility.type.sourceGroup="Any"
+AdvSceneSwitcher.action.sceneVisibility.entry="On {{scenes}} {{actions}} {{sourceTypes}} {{sources}}"
 AdvSceneSwitcher.action.filter="Filter"
 AdvSceneSwitcher.action.filter.type.enable="Enable"
 AdvSceneSwitcher.action.filter.type.disable="Disable"
@@ -340,6 +353,10 @@ AdvSceneSwitcher.action.timer.type.continue="Continue"
 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}}"
 
 ; Transition Tab
 AdvSceneSwitcher.transitionTab.title="Transition"
@@ -614,6 +631,8 @@ AdvSceneSwitcher.selectWindowTip="Use \"OBS\" to specify OBS window\nUse \"Task
 
 AdvSceneSwitcher.status.active="Active"
 AdvSceneSwitcher.status.inactive="Inactive"
+AdvSceneSwitcher.running="Plugin running"
+AdvSceneSwitcher.stopped="Plugin stopped"
 
 AdvSceneSwitcher.unit.milliseconds="milliseconds"
 AdvSceneSwitcher.unit.secends="seconds"

forms/advanced-scene-switcher.ui

@@ -306,6 +306,30 @@
                 </item>
                </layout>
               </item>
+              <item>
+               <layout class="QHBoxLayout" name="horizontalLayout_2">
+                <item>
+                 <widget class="QCheckBox" name="showTrayNotifications">
+                  <property name="text">
+                   <string>AdvSceneSwitcher.generalTab.generalBehavior.showTrayNotifications</string>
+                  </property>
+                 </widget>
+                </item>
+                <item>
+                 <spacer name="horizontalSpacer_2">
+                  <property name="orientation">
+                   <enum>Qt::Horizontal</enum>
+                  </property>
+                  <property name="sizeHint" stdset="0">
+                   <size>
+                    <width>40</width>
+                    <height>20</height>
+                   </size>
+                  </property>
+                 </spacer>
+                </item>
+               </layout>
+              </item>
               <item>
                <layout class="QHBoxLayout" name="horizontalLayout_48">
                 <item>
@@ -355,8 +379,7 @@
                 <item>
                  <layout class="QHBoxLayout" name="horizontalLayout_41">
                   <item>
-                   <widget class="QListWidget" name="priorityList">
-                   </widget>
+                   <widget class="QListWidget" name="priorityList"/>
                   </item>
                  </layout>
                 </item>

src/advanced-scene-switcher.cpp

@@ -2,6 +2,7 @@
 #include <QAction>
 #include <QFileDialog>
 #include <regex>
+#include <filesystem>
 
 #include <obs-module.h>
 #include <obs-frontend-api.h>
@@ -19,6 +20,7 @@ SwitcherData *switcher = nullptr;
 AdvSceneSwitcher::AdvSceneSwitcher(QWidget *parent)
 	: QDialog(parent), ui(new Ui_AdvSceneSwitcher)
 {
+	switcher->settingsWindowOpened = true;
 	ui->setupUi(this);
 
 	std::lock_guard<std::mutex> lock(switcher->m);
@@ -27,6 +29,13 @@ AdvSceneSwitcher::AdvSceneSwitcher(QWidget *parent)
 	loadUI();
 }
 
+AdvSceneSwitcher::~AdvSceneSwitcher()
+{
+	if (switcher) {
+		switcher->settingsWindowOpened = false;
+	}
+}
+
 bool translationAvailable()
 {
 	return !!strcmp(obs_module_text("AdvSceneSwitcher.pluginName"),
@@ -36,9 +45,16 @@ bool translationAvailable()
 void AdvSceneSwitcher::loadUI()
 {
 	if (!translationAvailable()) {
-		(void)DisplayMessage(
-			"Failed to find plug-in's 'data' directory.\n"
-			"Please check installation instructions!");
+		QString msg = "Failed to find plug-in's 'data' directory.\n"
+			      "Please check installation instructions!\n\n"
+			      "Data most likely expected at:\n\n";
+#ifdef _WIN32
+		msg += QString::fromStdString(
+			(std::filesystem::current_path().string()));
+		msg += "/";
+#endif
+		msg += obs_get_module_data_path(obs_current_module());
+		(void)DisplayMessage(msg);
 	}
 
 #if __APPLE__
@@ -104,33 +120,23 @@ static void SaveSceneSwitcher(obs_data_t *save_data, bool saving, void *)
 {
 	if (saving) {
 		std::lock_guard<std::mutex> lock(switcher->m);
-
 		switcher->Prune();
-
 		obs_data_t *obj = obs_data_create();
-
 		switcher->saveSettings(obj);
-
 		obs_data_set_obj(save_data, "advanced-scene-switcher", obj);
-
 		obs_data_release(obj);
 	} else {
 		switcher->m.lock();
-
 		obs_data_t *obj =
 			obs_data_get_obj(save_data, "advanced-scene-switcher");
-
 		if (!obj) {
 			obj = obs_data_create();
 		}
 		if (switcher->versionChanged(obj, g_GIT_SHA1)) {
 			AskBackup(obj);
 		}
-
 		switcher->loadSettings(obj);
-
 		obs_data_release(obj);
-
 		switcher->m.unlock();
 
 		// Stop the scene switcher at least once to
@@ -166,9 +172,7 @@ void SwitcherData::Thread()
 		bool setPrevSceneAfterLinger = false;
 		bool macroMatch = false;
 		macroSceneSwitched = false;
-
 		endTime = std::chrono::high_resolution_clock::now();
-
 		auto runTime =
 			std::chrono::duration_cast<std::chrono::milliseconds>(
 				endTime - startTime);
@@ -415,12 +419,18 @@ void SwitcherData::Start()
 	if (networkConfig.ClientEnabled) {
 		client.connect(networkConfig.GetClientUri());
 	}
+
+	if (showSystemTrayNotifications) {
+		DisplayTrayMessage(
+			obs_module_text("AdvSceneSwitcher.pluginName"),
+			obs_module_text("AdvSceneSwitcher.running"));
+	}
 }
 
 void ResetMacroCounters()
 {
 	for (auto &m : switcher->macros) {
-		m.ResetCount();
+		m->ResetCount();
 	}
 }
 
@@ -441,6 +451,19 @@ void SwitcherData::Stop()
 
 	server.stop();
 	client.disconnect();
+
+	for (auto &t : audioHelperThreads) {
+		if (t.joinable()) {
+			t.join();
+		}
+	}
+	audioHelperThreads.clear();
+
+	if (showSystemTrayNotifications) {
+		DisplayTrayMessage(
+			obs_module_text("AdvSceneSwitcher.pluginName"),
+			obs_module_text("AdvSceneSwitcher.stopped"));
+	}
 }
 
 void SwitcherData::setWaitScene()
@@ -558,6 +581,18 @@ void setTranstionEnd()
 		std::chrono::high_resolution_clock::now();
 }
 
+void setStreamStarting()
+{
+	switcher->lastStreamStartingTime =
+		std::chrono::high_resolution_clock::now();
+}
+
+void setStreamStopping()
+{
+	switcher->lastStreamStoppingTime =
+		std::chrono::high_resolution_clock::now();
+}
+
 // Note to future self:
 // be careful using switcher->m here as there is potential for deadlocks when using
 // frontend functions such as obs_frontend_set_current_scene()
@@ -597,11 +632,19 @@ static void OBSEvent(enum obs_frontend_event event, void *switcher)
 	case OBS_FRONTEND_EVENT_TRANSITION_STOPPED:
 		setTranstionEnd();
 		break;
+	case OBS_FRONTEND_EVENT_STREAMING_STARTING:
+		setStreamStarting();
+		break;
+	case OBS_FRONTEND_EVENT_STREAMING_STOPPING:
+		setStreamStopping();
+		break;
 	default:
 		break;
 	}
 }
 
+AdvSceneSwitcher *ssWindow;
+
 extern "C" void InitSceneSwitcher()
 {
 	blog(LOG_INFO, "version: %s", g_GIT_TAG);
@@ -619,11 +662,16 @@ extern "C" void InitSceneSwitcher()
 	PlatformInit();
 
 	auto cb = []() {
-		QMainWindow *window =
-			(QMainWindow *)obs_frontend_get_main_window();
-
-		AdvSceneSwitcher ss(window);
-		ss.exec();
+		if (switcher->settingsWindowOpened) {
+			ssWindow->show();
+			ssWindow->raise();
+			ssWindow->activateWindow();
+		} else {
+			ssWindow = new AdvSceneSwitcher(
+				(QMainWindow *)obs_frontend_get_main_window());
+			ssWindow->setAttribute(Qt::WA_DeleteOnClose);
+			ssWindow->show();
+		}
 	};
 
 	obs_frontend_add_save_callback(SaveSceneSwitcher, nullptr);

src/file-selection.cpp

@@ -5,7 +5,7 @@
 #include <QFileDialog>
 
 FileSelection::FileSelection(FileSelection::Type type, QWidget *parent)
-	: _type(type), QWidget(parent)
+	: QWidget(parent), _type(type)
 {
 	_filePath = new QLineEdit();
 	_browseButton =

src/general.cpp

@@ -186,6 +186,9 @@ void AdvSceneSwitcher::on_toggleStartButton_clicked()
 
 void AdvSceneSwitcher::closeEvent(QCloseEvent *)
 {
+	if (!switcher) {
+		return;
+	}
 	switcher->windowPos = this->pos();
 	switcher->windowSize = this->size();
 
@@ -210,6 +213,15 @@ void AdvSceneSwitcher::on_saveWindowGeo_stateChanged(int state)
 	switcher->saveWindowGeo = state;
 }
 
+void AdvSceneSwitcher::on_showTrayNotifications_stateChanged(int state)
+{
+	if (loading) {
+		return;
+	}
+
+	switcher->showSystemTrayNotifications = state;
+}
+
 void AdvSceneSwitcher::on_uiHintsDisable_stateChanged(int state)
 {
 	if (loading) {
@@ -503,6 +515,8 @@ void SwitcherData::saveGeneralSettings(obs_data_t *obj)
 			 static_cast<int>(autoStartEvent));
 
 	obs_data_set_bool(obj, "verbose", verbose);
+	obs_data_set_bool(obj, "showSystemTrayNotifications",
+			  showSystemTrayNotifications);
 	obs_data_set_bool(obj, "disableHints", disableHints);
 
 	obs_data_set_int(obj, "priority0", functionNamesByPriority[0]);
@@ -574,6 +588,8 @@ void SwitcherData::loadGeneralSettings(obs_data_t *obj)
 		obs_data_get_int(obj, "autoStartEvent"));
 
 	verbose = obs_data_get_bool(obj, "verbose");
+	showSystemTrayNotifications =
+		obs_data_get_bool(obj, "showSystemTrayNotifications");
 	disableHints = obs_data_get_bool(obj, "disableHints");
 
 	obs_data_set_default_int(obj, "priority0", default_priority_0);
@@ -800,6 +816,8 @@ void AdvSceneSwitcher::setupGeneralTab()
 
 	ui->verboseLogging->setChecked(switcher->verbose);
 	ui->saveWindowGeo->setChecked(switcher->saveWindowGeo);
+	ui->showTrayNotifications->setChecked(
+		switcher->showSystemTrayNotifications);
 	ui->uiHintsDisable->setChecked(switcher->disableHints);
 
 	for (int p : switcher->functionNamesByPriority) {

src/headers/advanced-scene-switcher.hpp

@@ -29,6 +29,7 @@ public:
 	bool currentStatusActive = false;
 
 	AdvSceneSwitcher(QWidget *parent);
+	~AdvSceneSwitcher();
 
 	void reject() override;
 	void closeEvent(QCloseEvent *event) override;
@@ -52,8 +53,8 @@ public:
 	void SetEditMacro(Macro &m);
 	void HighlightAction(int idx);
 	void HighlightCondition(int idx);
-	void PopulateMacroActions(Macro &m, int afterIdx = 0);
-	void PopulateMacroConditions(Macro &m, int afterIdx = 0);
+	void PopulateMacroActions(Macro &m, uint32_t afterIdx = 0);
+	void PopulateMacroConditions(Macro &m, uint32_t afterIdx = 0);
 	void ConnectControlSignals(MacroActionEdit *);
 	void ConnectControlSignals(MacroConditionEdit *);
 	void SwapActions(Macro *m, int pos1, int pos2);
@@ -164,6 +165,7 @@ public slots:
 
 	void on_verboseLogging_stateChanged(int state);
 	void on_saveWindowGeo_stateChanged(int state);
+	void on_showTrayNotifications_stateChanged(int state);
 	void on_uiHintsDisable_stateChanged(int state);
 
 	void on_exportSettings_clicked();

src/headers/macro-action-audio.hpp

@@ -1,7 +1,10 @@
 #pragma once
-#include <QSpinBox>
-#include <QHBoxLayout>
 #include "macro-action-edit.hpp"
+#include "duration-control.hpp"
+
+#include <QSpinBox>
+#include <QCheckBox>
+#include <QHBoxLayout>
 
 enum class AudioAction {
 	MUTE,
@@ -26,6 +29,8 @@ public:
 	OBSWeakSource _audioSource;
 	AudioAction _action = AudioAction::MUTE;
 	int _volume = 0;
+	bool _fade = false;
+	Duration _duration;
 
 private:
 	static bool _registered;
@@ -53,6 +58,8 @@ private slots:
 	void SourceChanged(const QString &text);
 	void ActionChanged(int value);
 	void VolumeChanged(int value);
+	void FadeChanged(int value);
+	void DurationChanged(double seconds);
 signals:
 	void HeaderInfoChanged(const QString &);
 
@@ -60,9 +67,11 @@ protected:
 	QComboBox *_audioSources;
 	QComboBox *_actions;
 	QSpinBox *_volumePercent;
+	QCheckBox *_fade;
+	DurationSelection *_duration;
+	QHBoxLayout *_fadeLayout;
 	std::shared_ptr<MacroActionAudio> _entryData;
 
 private:
-	QHBoxLayout *_mainLayout;
 	bool _loading = true;
 };

src/headers/macro-action-random.hpp

@@ -0,0 +1,63 @@
+#pragma once
+#include "macro-action-edit.hpp"
+#include "macro-selection.hpp"
+
+#include <QPushButton>
+#include <QListWidget>
+#include <unordered_map>
+
+class MacroActionRandom : public MultiMacroRefAction {
+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<MacroActionRandom>();
+	}
+
+	// TODO: add weights to each macro ...
+	// std::unordered_map<MacroRef, int> _weights;
+
+private:
+	MacroRef lastRandomMacro;
+	static bool _registered;
+	static const std::string id;
+};
+
+class MacroActionRandomEdit : public QWidget {
+	Q_OBJECT
+
+public:
+	MacroActionRandomEdit(
+		QWidget *parent,
+		std::shared_ptr<MacroActionRandom> entryData = nullptr);
+	void UpdateEntryData();
+	static QWidget *Create(QWidget *parent,
+			       std::shared_ptr<MacroAction> action)
+	{
+		return new MacroActionRandomEdit(
+			parent,
+			std::dynamic_pointer_cast<MacroActionRandom>(action));
+	}
+
+private slots:
+	void MacroRemove(const QString &name);
+	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;
+	QListWidget *_macroList;
+	QPushButton *_add;
+	QPushButton *_remove;
+	bool _loading = true;
+};

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

@@ -8,6 +8,11 @@ enum class SceneVisibilityAction {
 	HIDE,
 };
 
+enum class SceneItemSourceType {
+	SOURCE,
+	SOURCE_GROUP,
+};
+
 class MacroActionSceneVisibility : public MacroAction {
 public:
 	bool PerformAction();
@@ -22,7 +27,9 @@ public:
 	}
 
 	SceneSelection _scene;
+	SceneItemSourceType _sourceType = SceneItemSourceType::SOURCE;
 	OBSWeakSource _source;
+	std::string _sourceGroup = "";
 	SceneVisibilityAction _action = SceneVisibilityAction::SHOW;
 
 private:
@@ -49,6 +56,7 @@ public:
 
 private slots:
 	void SceneChanged(const SceneSelection &);
+	void SourceTypeChanged(int value);
 	void SourceChanged(const QString &text);
 	void ActionChanged(int value);
 signals:
@@ -56,6 +64,7 @@ signals:
 
 protected:
 	SceneSelectionWidget *_scenes;
+	QComboBox *_sourceTypes;
 	QComboBox *_sources;
 	QComboBox *_actions;
 	std::shared_ptr<MacroActionSceneVisibility> _entryData;

src/headers/macro-condition-macro.hpp

@@ -67,6 +67,7 @@ private slots:
 	void ConditionChanged(int cond);
 	void ResetClicked();
 	void UpdateCount();
+	void UpdatePaused();
 signals:
 	void HeaderInfoChanged(const QString &);
 
@@ -76,16 +77,17 @@ protected:
 	QComboBox *_counterConditions;
 	QSpinBox *_count;
 	QLabel *_currentCount;
+	QLabel *_pausedWarning;
 	QPushButton *_resetCount;
 	QHBoxLayout *_settingsLine1;
 	QHBoxLayout *_settingsLine2;
-	std::unique_ptr<QTimer> _timer;
+	QTimer _countTimer;
+	QTimer _pausedTimer;
 	std::shared_ptr<MacroConditionMacro> _entryData;
 
 private:
 	void ClearLayouts();
 	void SetupStateWidgets();
 	void SetupCountWidgets();
-	void ResetTimer();
 	bool _loading = true;
 };

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

@@ -0,0 +1,66 @@
+#pragma once
+#include "macro.hpp"
+#include "scene-selection.hpp"
+
+#include <QComboBox>
+
+enum class SceneVisibilityCondition {
+	SHOWN,
+	HIDDEN,
+};
+
+class MacroConditionSceneVisibility : public MacroCondition {
+public:
+	bool CheckCondition();
+	bool Save(obs_data_t *obj);
+	bool Load(obs_data_t *obj);
+	std::string GetShortDesc();
+	std::string GetId() { return id; };
+	static std::shared_ptr<MacroCondition> Create()
+	{
+		return std::make_shared<MacroConditionSceneVisibility>();
+	}
+
+	SceneSelection _scene;
+	OBSWeakSource _source;
+	SceneVisibilityCondition _condition = SceneVisibilityCondition::SHOWN;
+
+private:
+	static bool _registered;
+	static const std::string id;
+};
+
+class MacroConditionSceneVisibilityEdit : public QWidget {
+	Q_OBJECT
+
+public:
+	MacroConditionSceneVisibilityEdit(
+		QWidget *parent,
+		std::shared_ptr<MacroConditionSceneVisibility> cond = nullptr);
+	void UpdateEntryData();
+	static QWidget *Create(QWidget *parent,
+			       std::shared_ptr<MacroCondition> cond)
+	{
+		return new MacroConditionSceneVisibilityEdit(
+			parent,
+			std::dynamic_pointer_cast<MacroConditionSceneVisibility>(
+				cond));
+	}
+
+private slots:
+	void SceneChanged(const SceneSelection &);
+	void SourceChanged(const QString &text);
+	void ConditionChanged(int cond);
+signals:
+	void HeaderInfoChanged(const QString &);
+
+protected:
+	SceneSelectionWidget *_scenes;
+	QComboBox *_sources;
+	QComboBox *_conditions;
+
+	std::shared_ptr<MacroConditionSceneVisibility> _entryData;
+
+private:
+	bool _loading = true;
+};

src/headers/macro-condition-streaming.hpp

@@ -6,6 +6,8 @@
 enum class StreamState {
 	STOP,
 	START,
+	STARTING,
+	STOPPING,
 };
 
 class MacroConditionStream : public MacroCondition {
@@ -22,6 +24,9 @@ public:
 	StreamState _streamState;
 
 private:
+	std::chrono::high_resolution_clock::time_point _lastStreamStartingTime{};
+	std::chrono::high_resolution_clock::time_point _lastStreamStoppingTime{};
+
 	static bool _registered;
 	static const std::string id;
 };

src/headers/macro-condition-video.hpp

@@ -51,6 +51,7 @@ public:
 	VideoCondition _condition = VideoCondition::MATCH;
 	std::string _file = obs_module_text("AdvSceneSwitcher.enterPath");
 	bool _useAlphaAsMask = false;
+	bool _usePatternForChangedCheck = false;
 	PatternMatchData _patternData;
 	double _patternThreshold = 0.8;
 	cv::CascadeClassifier _objectCascade;
@@ -65,6 +66,7 @@ public:
 	int _throttleCount = 3;
 
 private:
+	bool OutputChanged();
 	bool ScreenshotContainsPattern();
 	bool ScreenshotContainsObject();
 	bool Compare();
@@ -127,6 +129,7 @@ private slots:
 	void ConditionChanged(int cond);
 	void ImagePathChanged(const QString &text);
 	void ImageBrowseButtonClicked();
+	void UsePatternForChangedCheckChanged(int value);
 	void PatternThresholdChanged(double);
 	void UseAlphaAsMaskChanged(int value);
 
@@ -148,6 +151,7 @@ protected:
 	QComboBox *_videoSelection;
 	QComboBox *_condition;
 
+	QCheckBox *_usePatternForChangedCheck;
 	FileSelection *_imagePath;
 	ThresholdSlider *_patternThreshold;
 	QCheckBox *_useAlphaAsMask;

src/headers/macro.hpp

@@ -77,7 +77,7 @@ public:
 	bool Matched() { return _matched; }
 	std::string Name() { return _name; }
 	void SetName(const std::string &name);
-	void SetPaused(bool pause = true) { _paused = pause; }
+	void SetPaused(bool pause = true);
 	bool Paused() { return _paused; }
 	int GetCount() { return _count; };
 	void ResetCount() { _count = 0; };
@@ -102,6 +102,7 @@ private:
 	void SetupHotkeys();
 	void ClearHotkeys();
 	void SetHotkeysDesc();
+	void ResetTimers();
 
 	std::string _name = "";
 	std::deque<std::shared_ptr<MacroCondition>> _conditions;
@@ -144,3 +145,9 @@ public:
 	void ResolveMacroRef();
 	MacroRef _macro;
 };
+
+class MultiMacroRefAction : public MacroAction {
+public:
+	void ResolveMacroRef();
+	std::vector<MacroRef> _macros;
+};

src/headers/switcher-data-structs.hpp

@@ -6,6 +6,7 @@
 #include <QDateTime>
 #include <QThread>
 #include <curl/curl.h>
+#include <unordered_map>
 
 #include "scene-group.hpp"
 #include "scene-trigger.hpp"
@@ -63,6 +64,8 @@ class SwitcherThread;
 struct SwitcherData {
 	SwitcherThread *th = nullptr;
 
+	bool settingsWindowOpened = false;
+
 	std::condition_variable cv;
 	std::mutex m;
 	bool transitionActive = false;
@@ -70,6 +73,7 @@ struct SwitcherData {
 	bool stop = false;
 	bool verbose = false;
 	bool disableHints = false;
+	bool showSystemTrayNotifications = false;
 	bool showFrame = false;
 	bool transitionOverrideOverride = false;
 	bool adjustActiveTransitionType = true;
@@ -81,6 +85,8 @@ struct SwitcherData {
 	OBSWeakSource previousScene = nullptr;
 	std::chrono::high_resolution_clock::time_point lastSceneChangeTime{};
 	std::chrono::high_resolution_clock::time_point lastTransitionEndTime{};
+	std::chrono::high_resolution_clock::time_point lastStreamStartingTime{};
+	std::chrono::high_resolution_clock::time_point lastStreamStoppingTime{};
 	OBSWeakSource lastRandomScene;
 	SceneGroup *lastRandomSceneGroup;
 	OBSWeakSource nonMatchingScene;
@@ -89,10 +95,14 @@ struct SwitcherData {
 	StartupBehavior startupBehavior = PERSIST;
 	AutoStartEvent autoStartEvent = AutoStartEvent::NEVER;
 
+	std::vector<std::thread> audioHelperThreads;
+	std::atomic_bool masterAudioFadeActive = {false};
+	std::unordered_map<std::string, std::atomic_bool> activeAudioFades;
+
 	Duration cooldown;
 	std::chrono::high_resolution_clock::time_point lastMatchTime;
 
-	std::deque<Macro> macros;
+	std::deque<std::shared_ptr<Macro>> macros;
 	std::condition_variable macroWaitCv;
 	std::atomic_bool abortMacroWait = {false};
 	bool macroSceneSwitched = false;

src/headers/utility.hpp

@@ -45,6 +45,7 @@ void placeWidgets(std::string text, QBoxLayout *layout,
 		  bool addStretch = true);
 void deleteLayoutItem(QLayoutItem *item);
 void clearLayout(QLayout *layout, int afterIdx = 0);
+void setLayoutVisible(QLayout *layout, bool visible);
 QMetaObject::Connection PulseWidget(QWidget *widget, QColor startColor,
 				    QColor = QColor(0, 0, 0, 0),
 				    QString specifier = "QLabel ",
@@ -55,6 +56,7 @@ void listAddClicked(QListWidget *list, QWidget *newWidget,
 bool listMoveUp(QListWidget *list);
 bool listMoveDown(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,
 		       bool selectable = false, const char *tooltip = "");
 void populateTransitionSelection(QComboBox *sel, bool addCurrent = true,
@@ -77,3 +79,4 @@ void populateFilterSelection(QComboBox *list,
 void populateSceneItemSelection(QComboBox *list,
 				OBSWeakSource sceneWeakSource = nullptr);
 void populateSceneItemSelection(QComboBox *list, SceneSelection &s);
+void populateSourceTypeSelection(QComboBox *list);

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

@@ -24,6 +24,9 @@
 #include <QStringList>
 #include <QRegularExpression>
 #include <QLibrary>
+#include <proc/readproc.h>
+#include <fstream>
+#include <sstream>
 
 static Display *xdisplay = 0;
 
@@ -363,17 +366,78 @@ bool isFullscreen(const std::string &title)
 void GetProcessList(QStringList &processes)
 {
 	processes.clear();
-	for (size_t i = 0; i < getTopLevelWindows().size(); ++i) {
-		std::string s = GetWindowTitle(i);
-		if (s != "")
-			processes << QString::fromStdString(s);
+	PROCTAB *proc = openproc(PROC_FILLSTAT);
+	proc_t proc_info;
+	memset(&proc_info, 0, sizeof(proc_info));
+	while (readproc(proc, &proc_info) != NULL) {
+		QString procName(proc_info.cmd);
+		if (!procName.isEmpty() && !processes.contains(proc_info.cmd)) {
+			processes << QString(proc_info.cmd);
+		}
 	}
+	closeproc(proc);
+}
+
+int getForegroundProcessPid()
+{
+	if (!ewmhIsSupported()) {
+		return -1;
+	}
+
+	auto dpy = disp();
+	Atom active = XInternAtom(dpy, "_NET_ACTIVE_WINDOW", true);
+	Atom actualType;
+	int format;
+	unsigned long num, bytes;
+	Window *window = 0;
+	int pid = -1;
+
+	Window rootWin = RootWindow(dpy, 0);
+
+	int xstatus = XGetWindowProperty(dpy, rootWin, active, 0L, ~0L, false,
+					 AnyPropertyType, &actualType, &format,
+					 &num, &bytes, (uint8_t **)&window);
+
+	if (xstatus == 0 && window == nullptr) {
+		return -1;
+	}
+
+	Atom atom, actual_type;
+	int actual_format;
+	unsigned long nitems;
+	unsigned long bytes_after;
+	unsigned char *prop;
+	atom = XInternAtom(dpy, "_NET_WM_PID", True);
+	auto status = XGetWindowProperty(dpy, *window, atom, 0, 1024, False,
+					 AnyPropertyType, &actual_type,
+					 &actual_format, &nitems, &bytes_after,
+					 &prop);
+
+	if (status != 0) {
+		return -2;
+	}
+	if (!prop) {
+		return -3;
+	}
+
+	pid = prop[1] * 256;
+	pid += prop[0];
+	return pid;
+}
+
+std::string getProcNameFromPid(int pid)
+{
+	std::string path = "/proc/" + std::to_string(pid) + "/comm";
+	std::ifstream t(path);
+	std::stringstream buffer;
+	buffer << t.rdbuf();
+	return buffer.str();
 }
 
 bool isInFocus(const QString &executable)
 {
-	std::string current;
-	GetCurrentWindowTitle(current);
+	auto pid = getForegroundProcessPid();
+	std::string current = getProcNameFromPid(pid);
 
 	// True if executable switch equals current window
 	bool equals = (executable.toStdString() == current);

src/macro-action-audio.cpp

@@ -18,6 +18,94 @@ const static std::map<AudioAction, std::string> actionTypes = {
 	 "AdvSceneSwitcher.action.audio.type.masterVolume"},
 };
 
+constexpr auto fadeInterval = std::chrono::milliseconds(100);
+constexpr float minFade = 0.000001f;
+
+void fadeSourceVolume(Duration duration, float vol, OBSWeakSource audioSource)
+{
+	auto s = obs_weak_source_get_source(audioSource);
+	if (!s) {
+		return;
+	}
+	float curVol = obs_source_get_volume(s);
+	obs_source_release(s);
+	bool volIncrease = curVol <= vol;
+	int nrSteps = duration.seconds * 1000 / fadeInterval.count();
+	float volDiff = (volIncrease) ? vol - curVol : curVol - vol;
+	float volStep = volDiff / nrSteps;
+
+	if (volStep < minFade) {
+		switcher->activeAudioFades[GetWeakSourceName(audioSource)] =
+			false;
+		return;
+	}
+
+	for (int step = 0; step < nrSteps && !switcher->stop; ++step) {
+		auto s = obs_weak_source_get_source(audioSource);
+		if (!s) {
+			return;
+		}
+		curVol = (volIncrease) ? curVol + volStep : curVol - volStep;
+		obs_source_set_volume(s, curVol);
+		std::this_thread::sleep_for(fadeInterval);
+		obs_source_release(s);
+	}
+
+	switcher->activeAudioFades[GetWeakSourceName(audioSource)] = false;
+}
+void fadeMasterVolume(Duration duration, float vol)
+{
+	float curVol = obs_get_master_volume();
+	bool volIncrease = curVol <= vol;
+	int nrSteps = duration.seconds * 1000 / fadeInterval.count();
+	float volDiff = (volIncrease) ? vol - curVol : curVol - vol;
+	float volStep = volDiff / nrSteps;
+
+	if (volStep < minFade) {
+		switcher->masterAudioFadeActive = false;
+		return;
+	}
+
+	for (int step = 0; step < nrSteps && !switcher->stop; ++step) {
+		curVol = (volIncrease) ? curVol + volStep : curVol - volStep;
+		obs_set_master_volume(curVol);
+		std::this_thread::sleep_for(fadeInterval);
+	}
+
+	switcher->masterAudioFadeActive = false;
+}
+
+void startSourceFade(Duration &duration, float vol, OBSWeakSource audioSource)
+{
+	if (!audioSource) {
+		return;
+	}
+	auto it =
+		switcher->activeAudioFades.find(GetWeakSourceName(audioSource));
+	if (it != switcher->activeAudioFades.end() && it->second == true) {
+		blog(LOG_WARNING,
+		     "Audio fade for volume of %s already active! New fade request will be ignored!",
+		     GetWeakSourceName(audioSource).c_str());
+		return;
+	}
+	switcher->activeAudioFades[GetWeakSourceName(audioSource)] = true;
+	switcher->audioHelperThreads.emplace_back(fadeSourceVolume, duration,
+						  vol, audioSource);
+}
+
+void startMasterFade(Duration &duration, float vol)
+{
+
+	if (switcher->masterAudioFadeActive) {
+		blog(LOG_WARNING,
+		     "Audio fade for master volume already active! New fade request will be ignored!");
+		return;
+	}
+	switcher->masterAudioFadeActive = true;
+	switcher->audioHelperThreads.emplace_back(fadeMasterVolume, duration,
+						  vol);
+}
+
 bool MacroActionAudio::PerformAction()
 {
 	auto s = obs_weak_source_get_source(_audioSource);
@@ -29,10 +117,19 @@ bool MacroActionAudio::PerformAction()
 		obs_source_set_muted(s, false);
 		break;
 	case AudioAction::SOURCE_VOLUME:
-		obs_source_set_volume(s, (float)_volume / 100.0f);
+		if (_fade) {
+			startSourceFade(_duration, (float)_volume / 100.0f,
+					_audioSource);
+		} else {
+			obs_source_set_volume(s, (float)_volume / 100.0f);
+		}
 		break;
 	case AudioAction::MASTER_VOLUME:
-		obs_set_master_volume((float)_volume / 100.0f);
+		if (_fade) {
+			startMasterFade(_duration, (float)_volume / 100.0f);
+		} else {
+			obs_set_master_volume((float)_volume / 100.0f);
+		}
 		break;
 	default:
 		break;
@@ -46,9 +143,10 @@ void MacroActionAudio::LogAction()
 	auto it = actionTypes.find(_action);
 	if (it != actionTypes.end()) {
 		vblog(LOG_INFO,
-		      "performed action \"%s\" for source \"%s\" with volume %d",
+		      "performed action \"%s\" for source \"%s\" with volume %d with fade %d %f",
 		      it->second.c_str(),
-		      GetWeakSourceName(_audioSource).c_str(), _volume);
+		      GetWeakSourceName(_audioSource).c_str(), _volume, _fade,
+		      _duration.seconds);
 	} else {
 		blog(LOG_WARNING, "ignored unknown audio action %d",
 		     static_cast<int>(_action));
@@ -58,20 +156,24 @@ void MacroActionAudio::LogAction()
 bool MacroActionAudio::Save(obs_data_t *obj)
 {
 	MacroAction::Save(obj);
+	_duration.Save(obj);
 	obs_data_set_string(obj, "audioSource",
 			    GetWeakSourceName(_audioSource).c_str());
 	obs_data_set_int(obj, "action", static_cast<int>(_action));
 	obs_data_set_int(obj, "volume", _volume);
+	obs_data_set_bool(obj, "fade", _fade);
 	return true;
 }
 
 bool MacroActionAudio::Load(obs_data_t *obj)
 {
 	MacroAction::Load(obj);
+	_duration.Load(obj);
 	const char *audioSourceName = obs_data_get_string(obj, "audioSource");
 	_audioSource = GetWeakSourceByName(audioSourceName);
 	_action = static_cast<AudioAction>(obs_data_get_int(obj, "action"));
 	_volume = obs_data_get_int(obj, "volume");
+	_fade = obs_data_get_bool(obj, "fade");
 	return true;
 }
 
@@ -100,6 +202,8 @@ MacroActionAudioEdit::MacroActionAudioEdit(
 	_volumePercent->setMinimum(0);
 	_volumePercent->setMaximum(2000);
 	_volumePercent->setSuffix("%");
+	_fade = new QCheckBox();
+	_duration = new DurationSelection(parent, false);
 
 	populateActionSelection(_actions);
 	populateAudioSelection(_audioSources);
@@ -111,15 +215,25 @@ MacroActionAudioEdit::MacroActionAudioEdit(
 			 SLOT(SourceChanged(const QString &)));
 	QWidget::connect(_volumePercent, SIGNAL(valueChanged(int)), this,
 			 SLOT(VolumeChanged(int)));
+	QWidget::connect(_fade, SIGNAL(stateChanged(int)), this,
+			 SLOT(FadeChanged(int)));
+	QWidget::connect(_duration, SIGNAL(DurationChanged(double)), this,
+			 SLOT(DurationChanged(double)));
 
-	QHBoxLayout *mainLayout = new QHBoxLayout;
 	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
-		{"{{audioSources}}", _audioSources},
-		{"{{actions}}", _actions},
-		{"{{volume}}", _volumePercent},
+		{"{{audioSources}}", _audioSources}, {"{{actions}}", _actions},
+		{"{{volume}}", _volumePercent},      {"{{fade}}", _fade},
+		{"{{duration}}", _duration},
 	};
+	QHBoxLayout *entryLayout = new QHBoxLayout;
 	placeWidgets(obs_module_text("AdvSceneSwitcher.action.audio.entry"),
-		     mainLayout, widgetPlaceholders);
+		     entryLayout, widgetPlaceholders);
+	_fadeLayout = new QHBoxLayout;
+	placeWidgets(obs_module_text("AdvSceneSwitcher.action.audio.fade"),
+		     _fadeLayout, widgetPlaceholders);
+	QVBoxLayout *mainLayout = new QVBoxLayout;
+	mainLayout->addLayout(entryLayout);
+	mainLayout->addLayout(_fadeLayout);
 	setLayout(mainLayout);
 
 	_entryData = entryData;
@@ -140,19 +254,11 @@ bool hasSourceControl(AudioAction action)
 
 void MacroActionAudioEdit::SetWidgetVisibility()
 {
-	if (hasVolumeControl(_entryData->_action)) {
-		_volumePercent->show();
-	} else {
-		_volumePercent->hide();
-	}
-
-	if (hasSourceControl(_entryData->_action)) {
-		_audioSources->show();
-	} else {
-		_audioSources->hide();
-	}
+	_volumePercent->setVisible(hasVolumeControl(_entryData->_action));
+	_audioSources->setVisible(hasSourceControl(_entryData->_action));
+	setLayoutVisible(_fadeLayout, hasVolumeControl(_entryData->_action));
+	adjustSize();
 }
-
 void MacroActionAudioEdit::UpdateEntryData()
 {
 	if (!_entryData) {
@@ -163,7 +269,8 @@ void MacroActionAudioEdit::UpdateEntryData()
 		GetWeakSourceName(_entryData->_audioSource).c_str());
 	_actions->setCurrentIndex(static_cast<int>(_entryData->_action));
 	_volumePercent->setValue(_entryData->_volume);
-
+	_fade->setChecked(_entryData->_fade);
+	_duration->SetDuration(_entryData->_duration);
 	SetWidgetVisibility();
 }
 
@@ -199,3 +306,23 @@ void MacroActionAudioEdit::VolumeChanged(int value)
 	std::lock_guard<std::mutex> lock(switcher->m);
 	_entryData->_volume = value;
 }
+
+void MacroActionAudioEdit::FadeChanged(int value)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_fade = value;
+}
+
+void MacroActionAudioEdit::DurationChanged(double seconds)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_duration.seconds = seconds;
+}

src/macro-action-edit.cpp

@@ -92,12 +92,14 @@ void MacroActionEdit::ActionSelectionChanged(const QString &text)
 		return;
 	}
 
+	auto idx = _entryData->get()->GetIndex();
 	std::string id = MacroActionFactory::GetIdByName(text);
 	HeaderInfoChanged("");
 
 	std::lock_guard<std::mutex> lock(switcher->m);
 	_entryData->reset();
 	*_entryData = MacroActionFactory::Create(id);
+	(*_entryData)->SetIndex(idx);
 	auto widget = MacroActionFactory::CreateWidget(id, this, *_entryData);
 	QWidget::connect(widget, SIGNAL(HeaderInfoChanged(const QString &)),
 			 this, SLOT(HeaderInfoChanged(const QString &)));

src/macro-action-filter.cpp

@@ -94,6 +94,7 @@ MacroActionFilterEdit::MacroActionFilterEdit(
 {
 	_sources = new QComboBox();
 	_filters = new QComboBox();
+	_filters->setSizeAdjustPolicy(QComboBox::AdjustToContents);
 	_actions = new QComboBox();
 	_getSettings = new QPushButton(
 		obs_module_text("AdvSceneSwitcher.action.filter.getSettings"));
@@ -165,6 +166,7 @@ void MacroActionFilterEdit::SourceChanged(const QString &text)
 	}
 	_filters->clear();
 	populateFilterSelection(_filters, _entryData->_source);
+	_filters->adjustSize();
 }
 
 void MacroActionFilterEdit::FilterChanged(const QString &text)

src/macro-action-hotkey.cpp

@@ -141,7 +141,7 @@ obs_key_combination keysToOBSKeycombo(const std::vector<HotkeyType> &keys)
 		return combo;
 	}
 
-	for (int i = 0; i < keys.size() - 1; i++) {
+	for (uint32_t i = 0; i < keys.size() - 1; i++) {
 		switch (keys[i]) {
 		case HotkeyType::Key_Shift_L:
 			combo.modifiers |= INTERACT_SHIFT_KEY;

src/macro-action-random.cpp

@@ -0,0 +1,263 @@
+#include "headers/macro-action-random.hpp"
+#include "headers/advanced-scene-switcher.hpp"
+#include "headers/name-dialog.hpp"
+#include "headers/utility.hpp"
+
+#include <cstdlib>
+
+const std::string MacroActionRandom::id = "random";
+
+bool MacroActionRandom::_registered = MacroActionFactory::Register(
+	MacroActionRandom::id,
+	{MacroActionRandom::Create, MacroActionRandomEdit::Create,
+	 "AdvSceneSwitcher.action.random"});
+
+std::vector<MacroRef> getPossibleMacros(std::vector<MacroRef> &macros,
+					MacroRef &lastRandomMacro)
+{
+	std::vector<MacroRef> res;
+	if (macros.size() == 1) {
+		if (macros[0]->Paused()) {
+			return res;
+		} else {
+			return macros;
+		}
+	}
+
+	for (auto &m : macros) {
+		if (m.get() && !m->Paused() &&
+		    !(lastRandomMacro.get() == m.get())) {
+			res.push_back(m);
+		}
+	}
+	return res;
+}
+
+bool MacroActionRandom::PerformAction()
+{
+	if (_macros.size() == 0) {
+		return true;
+	}
+
+	auto macros = getPossibleMacros(_macros, lastRandomMacro);
+	if (macros.size() == 0) {
+		return true;
+	}
+	if (macros.size() == 1) {
+		lastRandomMacro = macros[0];
+		return macros[0]->PerformAction();
+	}
+
+	size_t idx = std::rand() % (macros.size());
+	lastRandomMacro = macros[idx];
+	return macros[idx]->PerformAction();
+}
+
+void MacroActionRandom::LogAction()
+{
+	vblog(LOG_INFO, "running random macro");
+}
+
+bool MacroActionRandom::Save(obs_data_t *obj)
+{
+	MacroAction::Save(obj);
+	obs_data_array_t *args = obs_data_array_create();
+	for (auto &m : _macros) {
+		obs_data_t *array_obj = obs_data_create();
+		m.Save(array_obj);
+		obs_data_array_push_back(args, array_obj);
+		obs_data_release(array_obj);
+	}
+	obs_data_set_array(obj, "macros", args);
+	obs_data_array_release(args);
+	return true;
+}
+
+bool MacroActionRandom::Load(obs_data_t *obj)
+{
+	MacroAction::Load(obj);
+	obs_data_array_t *args = obs_data_get_array(obj, "macros");
+	size_t count = obs_data_array_count(args);
+	for (size_t i = 0; i < count; i++) {
+		obs_data_t *array_obj = obs_data_array_item(args, i);
+		MacroRef ref;
+		ref.Load(array_obj);
+		_macros.push_back(ref);
+		obs_data_release(array_obj);
+	}
+	obs_data_array_release(args);
+	return true;
+}
+
+MacroActionRandomEdit::MacroActionRandomEdit(
+	QWidget *parent, std::shared_ptr<MacroActionRandom> entryData)
+	: QWidget(parent)
+{
+	_macroSelection = new MacroSelection(window());
+	_macroList = new QListWidget();
+	_macroList->setSortingEnabled(true);
+	_add = new QPushButton();
+	_add->setMaximumSize(QSize(22, 22));
+	_add->setProperty("themeID",
+			  QVariant(QString::fromUtf8("addIconSmall")));
+	_add->setFlat(true);
+	_remove = new QPushButton();
+	_remove->setMaximumSize(QSize(22, 22));
+	_remove->setProperty("themeID",
+			     QVariant(QString::fromUtf8("removeIconSmall")));
+	_remove->setFlat(true);
+
+	QWidget::connect(_add, SIGNAL(clicked()), this, SLOT(AddMacro()));
+	QWidget::connect(_remove, SIGNAL(clicked()), this, SLOT(RemoveMacro()));
+	QWidget::connect(_macroList, SIGNAL(currentRowChanged(int)), this,
+			 SLOT(MacroSelectionChanged(int)));
+	QWidget::connect(window(),
+			 SIGNAL(MacroRenamed(const QString &, const QString &)),
+			 this,
+			 SLOT(MacroRename(const QString &, const QString &)));
+
+	auto *entryLayout = new QHBoxLayout;
+	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
+		{"{{macroSelection}}", _macroSelection},
+	};
+	placeWidgets(obs_module_text("AdvSceneSwitcher.action.random.entry"),
+		     entryLayout, widgetPlaceholders);
+
+	auto *argButtonLayout = new QHBoxLayout;
+	argButtonLayout->addWidget(_add);
+	argButtonLayout->addWidget(_remove);
+	argButtonLayout->addStretch();
+
+	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);
+
+	_entryData = entryData;
+	UpdateEntryData();
+	_loading = false;
+}
+
+void MacroActionRandomEdit::UpdateEntryData()
+{
+	if (!_entryData) {
+		return;
+	}
+
+	for (auto &m : _entryData->_macros) {
+		if (!m.get()) {
+			continue;
+		}
+		auto name = QString::fromStdString(m->Name());
+		QListWidgetItem *item = new QListWidgetItem(name, _macroList);
+		item->setData(Qt::UserRole, name);
+	}
+}
+
+void MacroActionRandomEdit::MacroRemove(const QString &name)
+{
+	if (_entryData) {
+		auto it = _entryData->_macros.begin();
+		while (it != _entryData->_macros.end()) {
+			if (it->get()->Name() == name.toStdString()) {
+				it = _entryData->_macros.erase(it);
+			} else {
+				++it;
+			}
+		}
+	}
+}
+
+void MacroActionRandomEdit::MacroRename(const QString &oldName,
+					const QString &newName)
+{
+	auto count = _macroList->count();
+	for (int idx = 0; idx < count; ++idx) {
+		QListWidgetItem *item = _macroList->item(idx);
+		QString itemString = item->data(Qt::UserRole).toString();
+		if (oldName == itemString) {
+			item->setData(Qt::UserRole, newName);
+			item->setText(newName);
+			break;
+		}
+	}
+}
+
+void MacroActionRandomEdit::AddMacro()
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	auto macroName = _macroSelection->currentText();
+	MacroRef macro(macroName.toStdString());
+
+	if (!macro.get()) {
+		return;
+	}
+
+	if (FindEntry(macro->Name()) != -1) {
+		return;
+	}
+
+	QVariant v = QVariant::fromValue(macroName);
+	QListWidgetItem *item = new QListWidgetItem(macroName, _macroList);
+	item->setData(Qt::UserRole, macroName);
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_macros.push_back(macro);
+}
+
+void MacroActionRandomEdit::RemoveMacro()
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	auto item = _macroList->currentItem();
+	if (!item) {
+		return;
+	}
+	std::string name = item->data(Qt::UserRole).toString().toStdString();
+	for (auto it = _entryData->_macros.begin();
+	     it != _entryData->_macros.end(); ++it) {
+		auto m = *it;
+		if (m.get() && m->Name() == name) {
+			_entryData->_macros.erase(it);
+			break;
+		}
+	}
+	delete item;
+}
+
+int MacroActionRandomEdit::FindEntry(const std::string &macro)
+{
+	int count = _macroList->count();
+	int idx = -1;
+
+	for (int i = 0; i < count; i++) {
+		QListWidgetItem *item = _macroList->item(i);
+		QString itemString = item->data(Qt::UserRole).toString();
+		if (QString::fromStdString(macro) == itemString) {
+			idx = i;
+			break;
+		}
+	}
+
+	return idx;
+}
+
+void MacroActionRandomEdit::MacroSelectionChanged(int idx)
+{
+	if (_loading || !_entryData || idx == -1) {
+		return;
+	}
+
+	QListWidgetItem *item = _macroList->item(idx);
+	QString name = item->text();
+	_macroSelection->SetCurrentMacro(GetMacroByName(name.toUtf8().data()));
+}

src/macro-action-scene-visibility.cpp

@@ -17,14 +17,22 @@ const static std::map<SceneVisibilityAction, std::string> actionTypes = {
 	 "AdvSceneSwitcher.action.sceneVisibility.type.hide"},
 };
 
-struct VisInfo {
+const static std::map<SceneItemSourceType, std::string> sourceItemSourceTypes = {
+	{SceneItemSourceType::SOURCE,
+	 "AdvSceneSwitcher.action.sceneVisibility.type.source"},
+	{SceneItemSourceType::SOURCE_GROUP,
+	 "AdvSceneSwitcher.action.sceneVisibility.type.sourceGroup"},
+};
+
+struct VisibilityData {
 	std::string name;
 	bool visible;
 };
 
-static bool visibilityEnum(obs_scene_t *, obs_sceneitem_t *item, void *ptr)
+static bool visibilitySourceEnum(obs_scene_t *, obs_sceneitem_t *item,
+				 void *ptr)
 {
-	VisInfo *vInfo = reinterpret_cast<VisInfo *>(ptr);
+	VisibilityData *vInfo = reinterpret_cast<VisibilityData *>(ptr);
 	auto sourceName = obs_source_get_name(obs_sceneitem_get_source(item));
 	if (vInfo->name == sourceName) {
 		obs_sceneitem_set_visible(item, vInfo->visible);
@@ -32,7 +40,26 @@ static bool visibilityEnum(obs_scene_t *, obs_sceneitem_t *item, void *ptr)
 
 	if (obs_sceneitem_is_group(item)) {
 		obs_scene_t *scene = obs_sceneitem_group_get_scene(item);
-		obs_scene_enum_items(scene, visibilityEnum, ptr);
+		obs_scene_enum_items(scene, visibilitySourceEnum, ptr);
+	}
+
+	return true;
+}
+
+static bool visibilitySourceTypeEnum(obs_scene_t *, obs_sceneitem_t *item,
+				     void *ptr)
+{
+	VisibilityData *vInfo = reinterpret_cast<VisibilityData *>(ptr);
+
+	auto sourceTypeName = obs_source_get_display_name(
+		obs_source_get_id(obs_sceneitem_get_source(item)));
+	if (vInfo->name == sourceTypeName) {
+		obs_sceneitem_set_visible(item, vInfo->visible);
+	}
+
+	if (obs_sceneitem_is_group(item)) {
+		obs_scene_t *scene = obs_sceneitem_group_get_scene(item);
+		obs_scene_enum_items(scene, visibilitySourceTypeEnum, ptr);
 	}
 
 	return true;
@@ -43,18 +70,21 @@ bool MacroActionSceneVisibility::PerformAction()
 	auto s = obs_weak_source_get_source(_scene.GetScene());
 	auto scene = obs_scene_from_source(s);
 	auto sourceName = GetWeakSourceName(_source);
-	VisInfo vInfo = {sourceName, _action == SceneVisibilityAction::SHOW};
+	VisibilityData vInfo = {"", _action == SceneVisibilityAction::SHOW};
 
-	switch (_action) {
-	case SceneVisibilityAction::SHOW:
-		obs_scene_enum_items(scene, visibilityEnum, &vInfo);
+	switch (_sourceType) {
+	case SceneItemSourceType::SOURCE:
+		vInfo.name = sourceName;
+		obs_scene_enum_items(scene, visibilitySourceEnum, &vInfo);
 		break;
-	case SceneVisibilityAction::HIDE:
-		obs_scene_enum_items(scene, visibilityEnum, &vInfo);
+	case SceneItemSourceType::SOURCE_GROUP:
+		vInfo.name = _sourceGroup;
+		obs_scene_enum_items(scene, visibilitySourceTypeEnum, &vInfo);
 		break;
 	default:
 		break;
 	}
+
 	obs_source_release(s);
 	return true;
 }
@@ -63,10 +93,18 @@ void MacroActionSceneVisibility::LogAction()
 {
 	auto it = actionTypes.find(_action);
 	if (it != actionTypes.end()) {
-		vblog(LOG_INFO,
-		      "performed visibility action \"%s\" for source \"%s\" on scene \"%s\"",
-		      it->second.c_str(), GetWeakSourceName(_source).c_str(),
-		      _scene.ToString().c_str());
+		if (_sourceType == SceneItemSourceType::SOURCE) {
+			vblog(LOG_INFO,
+			      "performed visibility action \"%s\" for source \"%s\" on scene \"%s\"",
+			      it->second.c_str(),
+			      GetWeakSourceName(_source).c_str(),
+			      _scene.ToString().c_str());
+		} else {
+			vblog(LOG_INFO,
+			      "performed visibility action \"%s\" for any source type \"%s\" on scene \"%s\"",
+			      it->second.c_str(), _sourceGroup.c_str(),
+			      _scene.ToString().c_str());
+		}
 	} else {
 		blog(LOG_WARNING, "ignored unknown SceneVisibility action %d",
 		     static_cast<int>(_action));
@@ -77,8 +115,14 @@ bool MacroActionSceneVisibility::Save(obs_data_t *obj)
 {
 	MacroAction::Save(obj);
 	_scene.Save(obj);
-	obs_data_set_string(obj, "source", GetWeakSourceName(_source).c_str());
+	if (_sourceType == SceneItemSourceType::SOURCE) {
+		obs_data_set_string(obj, "source",
+				    GetWeakSourceName(_source).c_str());
+	} else {
+		obs_data_set_string(obj, "source", _sourceGroup.c_str());
+	}
 	obs_data_set_int(obj, "action", static_cast<int>(_action));
+	obs_data_set_int(obj, "sourceType", static_cast<int>(_sourceType));
 	return true;
 }
 
@@ -86,8 +130,11 @@ bool MacroActionSceneVisibility::Load(obs_data_t *obj)
 {
 	MacroAction::Load(obj);
 	_scene.Load(obj);
+	_sourceType = static_cast<SceneItemSourceType>(
+		obs_data_get_int(obj, "sourceType"));
 	const char *sourceName = obs_data_get_string(obj, "source");
 	_source = GetWeakSourceByName(sourceName);
+	_sourceGroup = sourceName;
 	_action = static_cast<SceneVisibilityAction>(
 		obs_data_get_int(obj, "action"));
 	return true;
@@ -95,9 +142,16 @@ bool MacroActionSceneVisibility::Load(obs_data_t *obj)
 
 std::string MacroActionSceneVisibility::GetShortDesc()
 {
-	if (_source) {
+	if (_sourceType == SceneItemSourceType::SOURCE && _source) {
 		return _scene.ToString() + " - " + GetWeakSourceName(_source);
 	}
+	if (_sourceType == SceneItemSourceType::SOURCE_GROUP &&
+	    !_sourceGroup.empty()) {
+		return _scene.ToString() + " - " +
+		       obs_module_text(
+			       "AdvSceneSwitcher.action.sceneVisibility.type.sourceGroup") +
+		       " " + _sourceGroup;
+	}
 	return "";
 }
 
@@ -108,31 +162,44 @@ static inline void populateActionSelection(QComboBox *list)
 	}
 }
 
+static inline void populateSourceItemTypeSelection(QComboBox *list)
+{
+	for (auto entry : sourceItemSourceTypes) {
+		list->addItem(obs_module_text(entry.second.c_str()));
+	}
+}
+
 MacroActionSceneVisibilityEdit::MacroActionSceneVisibilityEdit(
 	QWidget *parent, std::shared_ptr<MacroActionSceneVisibility> entryData)
 	: QWidget(parent)
 {
-	_scenes = new SceneSelectionWidget(window(), false, false, true);
+	_scenes = new SceneSelectionWidget(window(), false, true, true);
+	_sourceTypes = new QComboBox();
 	_sources = new QComboBox();
+	_sources->setSizeAdjustPolicy(QComboBox::AdjustToContents);
 	_actions = new QComboBox();
 
+	populateSourceItemTypeSelection(_sourceTypes);
 	populateActionSelection(_actions);
 
 	QWidget::connect(_actions, SIGNAL(currentIndexChanged(int)), this,
 			 SLOT(ActionChanged(int)));
 	QWidget::connect(_scenes, SIGNAL(SceneChanged(const SceneSelection &)),
 			 this, SLOT(SceneChanged(const SceneSelection &)));
+	QWidget::connect(_sourceTypes, SIGNAL(currentIndexChanged(int)), this,
+			 SLOT(SourceTypeChanged(int)));
 	QWidget::connect(_sources, SIGNAL(currentTextChanged(const QString &)),
 			 this, SLOT(SourceChanged(const QString &)));
 
 	QHBoxLayout *mainLayout = new QHBoxLayout;
 	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
 		{"{{scenes}}", _scenes},
+		{"{{sourceTypes}}", _sourceTypes},
 		{"{{sources}}", _sources},
 		{"{{actions}}", _actions},
 	};
 	placeWidgets(obs_module_text(
-			     "AdvSceneSwitcher.action.SceneVisibility.entry"),
+			     "AdvSceneSwitcher.action.sceneVisibility.entry"),
 		     mainLayout, widgetPlaceholders);
 	setLayout(mainLayout);
 
@@ -148,10 +215,17 @@ void MacroActionSceneVisibilityEdit::UpdateEntryData()
 	}
 
 	_actions->setCurrentIndex(static_cast<int>(_entryData->_action));
+	_sourceTypes->setCurrentIndex(
+		static_cast<int>(_entryData->_sourceType));
 	_scenes->SetScene(_entryData->_scene);
-	populateSceneItemSelection(_sources, _entryData->_scene);
-	_sources->setCurrentText(
-		GetWeakSourceName(_entryData->_source).c_str());
+	if (_entryData->_sourceType == SceneItemSourceType::SOURCE) {
+		populateSceneItemSelection(_sources, _entryData->_scene);
+		_sources->setCurrentText(
+			GetWeakSourceName(_entryData->_source).c_str());
+	} else {
+		populateSourceTypeSelection(_sources);
+		_sources->setCurrentText(_entryData->_sourceGroup.c_str());
+	}
 }
 
 void MacroActionSceneVisibilityEdit::SceneChanged(const SceneSelection &s)
@@ -165,6 +239,26 @@ void MacroActionSceneVisibilityEdit::SceneChanged(const SceneSelection &s)
 	}
 	_sources->clear();
 	populateSceneItemSelection(_sources, _entryData->_scene);
+	_sources->adjustSize();
+}
+
+void MacroActionSceneVisibilityEdit::SourceTypeChanged(int value)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+	{
+		std::lock_guard<std::mutex> lock(switcher->m);
+		_entryData->_sourceType =
+			static_cast<SceneItemSourceType>(value);
+	}
+
+	_sources->clear();
+	if (_entryData->_sourceType == SceneItemSourceType::SOURCE) {
+		populateSceneItemSelection(_sources, _entryData->_scene);
+	} else {
+		populateSourceTypeSelection(_sources);
+	}
 }
 
 void MacroActionSceneVisibilityEdit::SourceChanged(const QString &text)
@@ -174,7 +268,15 @@ void MacroActionSceneVisibilityEdit::SourceChanged(const QString &text)
 	}
 
 	std::lock_guard<std::mutex> lock(switcher->m);
-	_entryData->_source = GetWeakSourceByQString(text);
+	if (_entryData->_sourceType == SceneItemSourceType::SOURCE) {
+		_entryData->_source = GetWeakSourceByQString(text);
+	} else {
+		if (text == obs_module_text("AdvSceneSwitcher.selectItem")) {
+			_entryData->_sourceGroup = "";
+		} else {
+			_entryData->_sourceGroup = text.toStdString();
+		}
+	}
 	emit HeaderInfoChanged(
 		QString::fromStdString(_entryData->GetShortDesc()));
 }

src/macro-condition-edit.cpp

@@ -188,6 +188,7 @@ void MacroConditionEdit::ConditionSelectionChanged(const QString &text)
 		return;
 	}
 
+	auto idx = _entryData->get()->GetIndex();
 	std::string id = MacroConditionFactory::GetIdByName(text);
 
 	auto temp = DurationConstraint();
@@ -198,6 +199,7 @@ void MacroConditionEdit::ConditionSelectionChanged(const QString &text)
 	auto logic = (*_entryData)->GetLogicType();
 	_entryData->reset();
 	*_entryData = MacroConditionFactory::Create(id);
+	(*_entryData)->SetIndex(idx);
 	(*_entryData)->SetLogicType(logic);
 	auto widget =
 		MacroConditionFactory::CreateWidget(id, this, *_entryData);

src/macro-condition-filter.cpp

@@ -96,6 +96,7 @@ MacroConditionFilterEdit::MacroConditionFilterEdit(
 {
 	_sources = new QComboBox();
 	_filters = new QComboBox();
+	_filters->setSizeAdjustPolicy(QComboBox::AdjustToContents);
 	_conditions = new QComboBox();
 	_getSettings = new QPushButton(obs_module_text(
 		"AdvSceneSwitcher.condition.filter.getSettings"));
@@ -159,6 +160,7 @@ void MacroConditionFilterEdit::SourceChanged(const QString &text)
 	}
 	_filters->clear();
 	populateFilterSelection(_filters, _entryData->_source);
+	_filters->adjustSize();
 }
 
 void MacroConditionFilterEdit::FilterChanged(const QString &text)

src/macro-condition-macro.cpp

@@ -125,6 +125,8 @@ MacroConditionMacroEdit::MacroConditionMacroEdit(
 	_currentCount = new QLabel(parent);
 	_resetCount = new QPushButton(obs_module_text(
 		"AdvSceneSwitcher.condition.macro.count.reset"));
+	_pausedWarning = new QLabel(obs_module_text(
+		"AdvSceneSwitcher.condition.macro.pausedWarning"));
 
 	_count->setMaximum(10000000);
 	populateTypeSelection(_types);
@@ -156,9 +158,18 @@ MacroConditionMacroEdit::MacroConditionMacroEdit(
 	mainLayout->addLayout(typesLayout);
 	mainLayout->addLayout(_settingsLine1);
 	mainLayout->addLayout(_settingsLine2);
+	mainLayout->addWidget(_pausedWarning);
 	setLayout(mainLayout);
 
 	_entryData = entryData;
+
+	connect(&_countTimer, SIGNAL(timeout()), this, SLOT(UpdateCount()));
+	_countTimer.start(1000);
+
+	_pausedWarning->setVisible(false);
+	connect(&_pausedTimer, SIGNAL(timeout()), this, SLOT(UpdatePaused()));
+	_pausedTimer.start(1000);
+
 	UpdateEntryData();
 	_loading = false;
 }
@@ -237,7 +248,6 @@ void MacroConditionMacroEdit::UpdateEntryData()
 	_counterConditions->setCurrentIndex(
 		static_cast<int>(_entryData->_counterCondition));
 	_count->setValue(_entryData->_count);
-	ResetTimer();
 }
 
 void MacroConditionMacroEdit::MacroChanged(const QString &text)
@@ -248,7 +258,6 @@ void MacroConditionMacroEdit::MacroChanged(const QString &text)
 
 	std::lock_guard<std::mutex> lock(switcher->m);
 	_entryData->_macro.UpdateRef(text);
-	ResetTimer();
 	emit HeaderInfoChanged(
 		QString::fromStdString(_entryData->GetShortDesc()));
 }
@@ -303,7 +312,6 @@ void MacroConditionMacroEdit::ResetClicked()
 	}
 
 	_entryData->_macro->ResetCount();
-	ResetTimer();
 }
 
 void MacroConditionMacroEdit::UpdateCount()
@@ -316,9 +324,9 @@ void MacroConditionMacroEdit::UpdateCount()
 	}
 }
 
-void MacroConditionMacroEdit::ResetTimer()
+void MacroConditionMacroEdit::UpdatePaused()
 {
-	_timer.reset(new QTimer(this));
-	connect(_timer.get(), SIGNAL(timeout()), this, SLOT(UpdateCount()));
-	_timer->start(1000);
+	_pausedWarning->setVisible(_entryData && _entryData->_macro.get() &&
+				   _entryData->_macro->Paused());
+	adjustSize();
 }

src/macro-condition-scene-visibility.cpp

@@ -0,0 +1,184 @@
+#include "headers/macro-condition-edit.hpp"
+#include "headers/macro-condition-scene-visibility.hpp"
+#include "headers/utility.hpp"
+#include "headers/advanced-scene-switcher.hpp"
+
+#include <regex>
+
+const std::string MacroConditionSceneVisibility::id = "scene_visibility";
+
+bool MacroConditionSceneVisibility::_registered =
+	MacroConditionFactory::Register(
+		MacroConditionSceneVisibility::id,
+		{MacroConditionSceneVisibility::Create,
+		 MacroConditionSceneVisibilityEdit::Create,
+		 "AdvSceneSwitcher.condition.sceneVisibility"});
+
+static std::map<SceneVisibilityCondition, std::string>
+	SceneVisibilityConditionTypes = {
+		{SceneVisibilityCondition::SHOWN,
+		 "AdvSceneSwitcher.condition.sceneVisibility.type.shown"},
+		{SceneVisibilityCondition::HIDDEN,
+		 "AdvSceneSwitcher.condition.sceneVisibility.type.hidden"},
+};
+
+struct VisibilityData {
+	std::string name;
+	bool visible;
+	bool result;
+};
+
+static bool visibilityEnum(obs_scene_t *, obs_sceneitem_t *item, void *ptr)
+{
+	VisibilityData *vInfo = reinterpret_cast<VisibilityData *>(ptr);
+	auto sourceName = obs_source_get_name(obs_sceneitem_get_source(item));
+	if (vInfo->name == sourceName &&
+	    obs_sceneitem_visible(item) == vInfo->visible) {
+		vInfo->result = true;
+		return false;
+	}
+
+	if (obs_sceneitem_is_group(item)) {
+		obs_scene_t *scene = obs_sceneitem_group_get_scene(item);
+		obs_scene_enum_items(scene, visibilityEnum, ptr);
+	}
+
+	return true;
+}
+
+bool MacroConditionSceneVisibility::CheckCondition()
+{
+	if (!_source) {
+		return false;
+	}
+
+	auto s = obs_weak_source_get_source(_scene.GetScene());
+	auto scene = obs_scene_from_source(s);
+	auto sourceName = GetWeakSourceName(_source);
+	VisibilityData data = {sourceName,
+			       _condition == SceneVisibilityCondition::SHOWN,
+			       false};
+	obs_scene_enum_items(scene, visibilityEnum, &data);
+	obs_source_release(s);
+	return data.result;
+}
+
+bool MacroConditionSceneVisibility::Save(obs_data_t *obj)
+{
+	MacroCondition::Save(obj);
+	_scene.Save(obj);
+	obs_data_set_string(obj, "source", GetWeakSourceName(_source).c_str());
+
+	obs_data_set_int(obj, "condition", static_cast<int>(_condition));
+
+	return true;
+}
+
+bool MacroConditionSceneVisibility::Load(obs_data_t *obj)
+{
+	MacroCondition::Load(obj);
+	_scene.Load(obj);
+	const char *sourceName = obs_data_get_string(obj, "source");
+	_source = GetWeakSourceByName(sourceName);
+	_condition = static_cast<SceneVisibilityCondition>(
+		obs_data_get_int(obj, "condition"));
+	return true;
+}
+
+std::string MacroConditionSceneVisibility::GetShortDesc()
+{
+	if (_source) {
+		return _scene.ToString() + " - " + GetWeakSourceName(_source);
+	}
+	return "";
+}
+
+static inline void populateConditionSelection(QComboBox *list)
+{
+	for (auto entry : SceneVisibilityConditionTypes) {
+		list->addItem(obs_module_text(entry.second.c_str()));
+	}
+}
+
+MacroConditionSceneVisibilityEdit::MacroConditionSceneVisibilityEdit(
+	QWidget *parent,
+	std::shared_ptr<MacroConditionSceneVisibility> entryData)
+	: QWidget(parent)
+{
+	_scenes = new SceneSelectionWidget(window(), false, true, true);
+	_sources = new QComboBox();
+	_sources->setSizeAdjustPolicy(QComboBox::AdjustToContents);
+	_conditions = new QComboBox();
+
+	populateConditionSelection(_conditions);
+
+	QWidget::connect(_scenes, SIGNAL(SceneChanged(const SceneSelection &)),
+			 this, SLOT(SceneChanged(const SceneSelection &)));
+	QWidget::connect(_sources, SIGNAL(currentTextChanged(const QString &)),
+			 this, SLOT(SourceChanged(const QString &)));
+	QWidget::connect(_conditions, SIGNAL(currentIndexChanged(int)), this,
+			 SLOT(ConditionChanged(int)));
+
+	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
+		{"{{sources}}", _sources},
+		{"{{scenes}}", _scenes},
+		{"{{conditions}}", _conditions},
+	};
+	QHBoxLayout *mainLayout = new QHBoxLayout;
+	placeWidgets(
+		obs_module_text(
+			"AdvSceneSwitcher.condition.sceneVisibility.entry"),
+		mainLayout, widgetPlaceholders);
+	setLayout(mainLayout);
+
+	_entryData = entryData;
+	UpdateEntryData();
+	_loading = false;
+}
+
+void MacroConditionSceneVisibilityEdit::SourceChanged(const QString &text)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_source = GetWeakSourceByQString(text);
+}
+
+void MacroConditionSceneVisibilityEdit::SceneChanged(const SceneSelection &s)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+	{
+		std::lock_guard<std::mutex> lock(switcher->m);
+		_entryData->_scene = s;
+	}
+	_sources->clear();
+	populateSceneItemSelection(_sources, _entryData->_scene);
+	_sources->adjustSize();
+}
+
+void MacroConditionSceneVisibilityEdit::ConditionChanged(int index)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_condition = static_cast<SceneVisibilityCondition>(index);
+}
+
+void MacroConditionSceneVisibilityEdit::UpdateEntryData()
+{
+	if (!_entryData) {
+		return;
+	}
+
+	_conditions->setCurrentIndex(static_cast<int>(_entryData->_condition));
+	_scenes->SetScene(_entryData->_scene);
+	populateSceneItemSelection(_sources, _entryData->_scene);
+	_sources->setCurrentText(
+		GetWeakSourceName(_entryData->_source).c_str());
+}

src/macro-condition-streaming.cpp

@@ -13,11 +13,21 @@ bool MacroConditionStream::_registered = MacroConditionFactory::Register(
 static std::map<StreamState, std::string> streamStates = {
 	{StreamState::STOP, "AdvSceneSwitcher.condition.stream.state.stop"},
 	{StreamState::START, "AdvSceneSwitcher.condition.stream.state.start"},
+	{StreamState::STARTING,
+	 "AdvSceneSwitcher.condition.stream.state.starting"},
+	{StreamState::STOPPING,
+	 "AdvSceneSwitcher.condition.stream.state.stopping"},
 };
 
 bool MacroConditionStream::CheckCondition()
 {
 	bool stateMatch = false;
+
+	bool streamStarting = switcher->lastStreamStartingTime !=
+			      _lastStreamStartingTime;
+	bool streamStopping = switcher->lastStreamStoppingTime !=
+			      _lastStreamStoppingTime;
+
 	switch (_streamState) {
 	case StreamState::STOP:
 		stateMatch = !obs_frontend_streaming_active();
@@ -25,9 +35,22 @@ bool MacroConditionStream::CheckCondition()
 	case StreamState::START:
 		stateMatch = obs_frontend_streaming_active();
 		break;
+	case StreamState::STARTING:
+		stateMatch = streamStarting;
+		break;
+	case StreamState::STOPPING:
+		stateMatch = streamStopping;
+		break;
 	default:
 		break;
 	}
+
+	if (streamStarting) {
+		_lastStreamStartingTime = switcher->lastStreamStartingTime;
+	}
+	if (streamStopping) {
+		_lastStreamStoppingTime = switcher->lastStreamStoppingTime;
+	}
 	return stateMatch;
 }
 

src/macro-condition-video.cpp

@@ -99,6 +99,8 @@ bool MacroConditionVideo::Save(obs_data_t *obj)
 			    GetWeakSourceName(_videoSource).c_str());
 	obs_data_set_int(obj, "condition", static_cast<int>(_condition));
 	obs_data_set_string(obj, "filePath", _file.c_str());
+	obs_data_set_bool(obj, "usePatternForChangedCheck",
+			  _usePatternForChangedCheck);
 	obs_data_set_double(obj, "threshold", _patternThreshold);
 	obs_data_set_bool(obj, "useAlphaAsMask", _useAlphaAsMask);
 	obs_data_set_string(obj, "modelDataPath", _modelDataPath.c_str());
@@ -132,6 +134,8 @@ bool MacroConditionVideo::Load(obs_data_t *obj)
 	_condition =
 		static_cast<VideoCondition>(obs_data_get_int(obj, "condition"));
 	_file = obs_data_get_string(obj, "filePath");
+	_usePatternForChangedCheck =
+		obs_data_get_bool(obj, "usePatternForChangedCheck");
 	_patternThreshold = obs_data_get_double(obj, "threshold");
 	_useAlphaAsMask = obs_data_get_bool(obj, "useAlphaAsMask");
 	_modelDataPath = obs_data_get_string(obj, "modelDataPath");
@@ -284,6 +288,18 @@ bool MacroConditionVideo::ScreenshotContainsPattern()
 	return countNonZero(result) > 0;
 }
 
+bool MacroConditionVideo::OutputChanged()
+{
+	if (_usePatternForChangedCheck) {
+		cv::Mat result;
+		_patternData = createPatternData(_matchImage);
+		matchPattern(_screenshotData->image, _patternData,
+			     _patternThreshold, result, _useAlphaAsMask);
+		return countNonZero(result) == 0;
+	}
+	return _screenshotData->image != _matchImage;
+}
+
 std::vector<cv::Rect> matchObject(QImage &img, cv::CascadeClassifier &cascade,
 				  double scaleFactor, int minNeighbors,
 				  cv::Size minSize, cv::Size maxSize)
@@ -319,9 +335,9 @@ bool MacroConditionVideo::Compare()
 	case VideoCondition::DIFFER:
 		return _screenshotData->image != _matchImage;
 	case VideoCondition::HAS_CHANGED:
-		return _screenshotData->image != _matchImage;
+		return OutputChanged();
 	case VideoCondition::HAS_NOT_CHANGED:
-		return _screenshotData->image == _matchImage;
+		return !OutputChanged();
 	case VideoCondition::NO_IMAGE:
 		return _screenshotData->image.isNull();
 	case VideoCondition::PATTERN:
@@ -398,6 +414,10 @@ MacroConditionVideoEdit::MacroConditionVideoEdit(
 
 	_imagePath = new FileSelection();
 	_imagePath->Button()->disconnect();
+	_usePatternForChangedCheck = new QCheckBox(obs_module_text(
+		"AdvSceneSwitcher.condition.video.usePatternForChangedCheck"));
+	_usePatternForChangedCheck->setToolTip(obs_module_text(
+		"AdvSceneSwitcher.condition.video.usePatternForChangedCheck.tooltip"));
 	_patternThreshold = new ThresholdSlider(
 		0., 1.,
 		obs_module_text(
@@ -445,6 +465,8 @@ MacroConditionVideoEdit::MacroConditionVideoEdit(
 			 SLOT(ImagePathChanged(const QString &)));
 	QWidget::connect(_imagePath->Button(), SIGNAL(clicked()), this,
 			 SLOT(ImageBrowseButtonClicked()));
+	QWidget::connect(_usePatternForChangedCheck, SIGNAL(stateChanged(int)),
+			 this, SLOT(UsePatternForChangedCheckChanged(int)));
 	QWidget::connect(_patternThreshold, SIGNAL(DoubleValueChanged(double)),
 			 this, SLOT(PatternThresholdChanged(double)));
 	QWidget::connect(_useAlphaAsMask, SIGNAL(stateChanged(int)), this,
@@ -523,6 +545,7 @@ MacroConditionVideoEdit::MacroConditionVideoEdit(
 	showMatchLayout->addStretch();
 	QVBoxLayout *mainLayout = new QVBoxLayout;
 	mainLayout->addLayout(entryLine1Layout);
+	mainLayout->addWidget(_usePatternForChangedCheck);
 	mainLayout->addWidget(_patternThreshold);
 	mainLayout->addWidget(_useAlphaAsMask);
 	mainLayout->addLayout(_modelPathLayout);
@@ -683,6 +706,18 @@ void MacroConditionVideoEdit::ImageBrowseButtonClicked()
 	ImagePathChanged(path);
 }
 
+void MacroConditionVideoEdit::UsePatternForChangedCheckChanged(int value)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_usePatternForChangedCheck = value;
+	_patternThreshold->setVisible(value);
+	adjustSize();
+}
+
 void MacroConditionVideoEdit::PatternThresholdChanged(double value)
 {
 	if (_loading || !_entryData) {
@@ -828,9 +863,9 @@ void MacroConditionVideoEdit::ShowMatchClicked()
 	}
 
 	QImage markedIamge;
-	QImage pattern = _entryData->GetMatchImage();
 	if (_entryData->_condition == VideoCondition::PATTERN) {
 		cv::Mat result;
+		QImage pattern = _entryData->GetMatchImage();
 		matchPattern(screenshot->image, pattern,
 			     _entryData->_patternThreshold, result,
 			     _entryData->_useAlphaAsMask);
@@ -899,21 +934,25 @@ bool needsThrottleControls(VideoCondition cond)
 	       cond == VideoCondition::OBJECT;
 }
 
-void setLayoutVisible(QLayout *layout, bool visible)
+bool needsThreshold(VideoCondition cond)
 {
-	for (int i = 0; i < layout->count(); ++i) {
-		QWidget *widget = layout->itemAt(i)->widget();
-		if (widget != NULL) {
-			widget->setVisible(visible);
-		}
-	}
+	return cond == VideoCondition::PATTERN ||
+	       cond == VideoCondition::HAS_CHANGED ||
+	       cond == VideoCondition::HAS_NOT_CHANGED;
+}
+
+bool patternControlIsOptional(VideoCondition cond)
+{
+	return cond == VideoCondition::HAS_CHANGED ||
+	       cond == VideoCondition::HAS_NOT_CHANGED;
 }
 
 void MacroConditionVideoEdit::SetWidgetVisibility()
 {
 	_imagePath->setVisible(requiresFileInput(_entryData->_condition));
-	_patternThreshold->setVisible(_entryData->_condition ==
-				      VideoCondition::PATTERN);
+	_usePatternForChangedCheck->setVisible(
+		patternControlIsOptional(_entryData->_condition));
+	_patternThreshold->setVisible(needsThreshold(_entryData->_condition));
 	_useAlphaAsMask->setVisible(_entryData->_condition ==
 				    VideoCondition::PATTERN);
 	_showMatch->setVisible(needsShowMatch(_entryData->_condition));
@@ -931,6 +970,13 @@ void MacroConditionVideoEdit::SetWidgetVisibility()
 			 needsObjectControls(_entryData->_condition));
 	setLayoutVisible(_throttleControlLayout,
 			 needsThrottleControls(_entryData->_condition));
+
+	if (_entryData->_condition == VideoCondition::HAS_CHANGED ||
+	    _entryData->_condition == VideoCondition::HAS_NOT_CHANGED) {
+		_patternThreshold->setVisible(
+			_entryData->_usePatternForChangedCheck);
+	}
+
 	adjustSize();
 }
 
@@ -944,6 +990,8 @@ void MacroConditionVideoEdit::UpdateEntryData()
 		GetWeakSourceName(_entryData->_videoSource).c_str());
 	_condition->setCurrentIndex(static_cast<int>(_entryData->_condition));
 	_imagePath->SetPath(QString::fromStdString(_entryData->_file));
+	_usePatternForChangedCheck->setChecked(
+		_entryData->_usePatternForChangedCheck);
 	_patternThreshold->SetDoubleValue(_entryData->_patternThreshold);
 	_useAlphaAsMask->setChecked(_entryData->_useAlphaAsMask);
 	_modelDataPath->SetPath(_entryData->GetModelDataPath().c_str());

src/macro-selection.cpp

@@ -16,7 +16,7 @@ MacroSelection::MacroSelection(QWidget *parent) : QComboBox(parent)
 	firstItem->setEnabled(false);
 
 	for (auto &m : switcher->macros) {
-		addItem(QString::fromStdString(m.Name()));
+		addItem(QString::fromStdString(m->Name()));
 	}
 
 	QWidget::connect(parent, SIGNAL(MacroAdded(const QString &)), this,

src/macro-tab.cpp

@@ -47,7 +47,7 @@ bool AdvSceneSwitcher::addNewMacro(std::string &name)
 
 	{
 		std::lock_guard<std::mutex> lock(switcher->m);
-		switcher->macros.emplace_back(name);
+		switcher->macros.emplace_back(std::make_shared<Macro>(name));
 	}
 	return true;
 }
@@ -84,8 +84,11 @@ void AdvSceneSwitcher::on_macroRemove_clicked()
 		switcher->abortMacroWait = true;
 		switcher->macroWaitCv.notify_one();
 		int idx = ui->macros->currentRow();
-		QString::fromStdString(switcher->macros[idx].Name());
+		QString::fromStdString(switcher->macros[idx]->Name());
 		switcher->macros.erase(switcher->macros.begin() + idx);
+		for (auto &m : switcher->macros) {
+			m->ResolveMacroRef();
+		}
 	}
 
 	delete item;
@@ -108,7 +111,7 @@ void AdvSceneSwitcher::on_macroUp_clicked()
 			  switcher->macros.begin() + index - 1);
 
 		for (auto &m : switcher->macros) {
-			m.ResolveMacroRef();
+			m->ResolveMacroRef();
 		}
 	}
 }
@@ -125,7 +128,7 @@ void AdvSceneSwitcher::on_macroDown_clicked()
 			  switcher->macros.begin() + index + 1);
 
 		for (auto &m : switcher->macros) {
-			m.ResolveMacroRef();
+			m->ResolveMacroRef();
 		}
 	}
 }
@@ -170,9 +173,8 @@ void AdvSceneSwitcher::on_macroName_editingFinished()
 	emit MacroRenamed(oldName, newName);
 }
 
-void AdvSceneSwitcher::PopulateMacroActions(Macro &m, int afterIdx)
+void AdvSceneSwitcher::PopulateMacroActions(Macro &m, uint32_t afterIdx)
 {
-	bool root = afterIdx == 0;
 	auto &actions = m.Actions();
 	for (; afterIdx < actions.size(); afterIdx++) {
 		auto newEntry = new MacroActionEdit(this, &actions[afterIdx],
@@ -180,12 +182,11 @@ void AdvSceneSwitcher::PopulateMacroActions(Macro &m, int afterIdx)
 		ConnectControlSignals(newEntry);
 		ui->macroEditActionLayout->addWidget(newEntry);
 		ui->macroEditActionHelp->setVisible(false);
-		root = false;
 	}
 	ui->macroEditActionHelp->setVisible(actions.size() == 0);
 }
 
-void AdvSceneSwitcher::PopulateMacroConditions(Macro &m, int afterIdx)
+void AdvSceneSwitcher::PopulateMacroConditions(Macro &m, uint32_t afterIdx)
 {
 	bool root = afterIdx == 0;
 	auto &conditions = m.Conditions();
@@ -314,12 +315,12 @@ void AdvSceneSwitcher::on_macros_itemChanged(QListWidgetItem *item)
 void AdvSceneSwitcher::setupMacroTab()
 {
 	for (auto &m : switcher->macros) {
-		QString text = QString::fromStdString(m.Name());
+		QString text = QString::fromStdString(m->Name());
 
 		QListWidgetItem *item = new QListWidgetItem(text, ui->macros);
 		item->setData(Qt::UserRole, text);
 		item->setFlags(item->flags() | Qt::ItemIsUserCheckable);
-		if (m.Paused()) {
+		if (m->Paused()) {
 			item->setCheckState(Qt::Unchecked);
 		} else {
 			item->setCheckState(Qt::Checked);
@@ -392,8 +393,8 @@ void AdvSceneSwitcher::CopyMacro()
 		return;
 	}
 
-	switcher->macros.back().Load(data);
-	switcher->macros.back().SetName(name);
+	switcher->macros.back()->Load(data);
+	switcher->macros.back()->SetName(name);
 	obs_data_release(data);
 
 	QString text = QString::fromStdString(name);

src/macro.cpp

@@ -36,6 +36,11 @@ bool Macro::CeckMatch()
 {
 	_matched = false;
 	for (auto &c : _conditions) {
+		if (_paused) {
+			vblog(LOG_INFO, "Macro %s is paused", _name.c_str());
+			return false;
+		}
+
 		auto startTime = std::chrono::high_resolution_clock::now();
 		bool cond = c->CheckCondition();
 		auto endTime = std::chrono::high_resolution_clock::now();
@@ -89,15 +94,11 @@ bool Macro::CeckMatch()
 
 	vblog(LOG_INFO, "Macro %s returned %d", _name.c_str(), _matched);
 
-	// Condition checks shall still be run even if macro is paused.
-	// Otherwise conditions might behave in unexpected ways when resuming.
-	//
-	// For example, audio could immediately match after unpause, when it
-	// matched before it was paused due to timers not being updated.
-	if (_paused) {
-		vblog(LOG_INFO, "Macro %s is paused", _name.c_str());
-		_matched = false;
-		return false;
+	// TODO: Move back to PerformAction() once new scene collection frontend
+	// events are available - see:
+	// https://github.com/obsproject/obs-studio/commit/feda1aaa283e8a99f6ba1159cfe6b9c1f2934a61
+	if (_matched && _count != std::numeric_limits<int>::max()) {
+		_count++;
 	}
 
 	return _matched;
@@ -113,9 +114,6 @@ bool Macro::PerformAction()
 			return false;
 		}
 	}
-	if (_count != std::numeric_limits<int>::max()) {
-		_count++;
-	}
 	return ret;
 }
 
@@ -125,6 +123,21 @@ void Macro::SetName(const std::string &name)
 	SetHotkeysDesc();
 }
 
+void Macro::ResetTimers()
+{
+	for (auto &c : _conditions) {
+		c->ResetDuration();
+	}
+}
+
+void Macro::SetPaused(bool pause)
+{
+	if (_paused && !pause) {
+		ResetTimers();
+	}
+	_paused = pause;
+}
+
 void Macro::UpdateActionIndices()
 {
 	int idx = 0;
@@ -290,13 +303,18 @@ void Macro::ResolveMacroRef()
 		MacroRefCondition *ref =
 			dynamic_cast<MacroRefCondition *>(c.get());
 		if (ref) {
-			ref->_macro.UpdateRef();
+			ref->ResolveMacroRef();
 		}
 	}
 	for (auto &a : _actions) {
 		MacroRefAction *ref = dynamic_cast<MacroRefAction *>(a.get());
 		if (ref) {
-			ref->_macro.UpdateRef();
+			ref->ResolveMacroRef();
+		}
+		MultiMacroRefAction *ref2 =
+			dynamic_cast<MultiMacroRefAction *>(a.get());
+		if (ref2) {
+			ref2->ResolveMacroRef();
 		}
 	}
 }
@@ -445,7 +463,7 @@ void SwitcherData::saveMacros(obs_data_t *obj)
 	for (auto &m : macros) {
 		obs_data_t *array_obj = obs_data_create();
 
-		m.Save(array_obj);
+		m->Save(array_obj);
 		obs_data_array_push_back(macroArray, array_obj);
 
 		obs_data_release(array_obj);
@@ -463,14 +481,14 @@ void SwitcherData::loadMacros(obs_data_t *obj)
 
 	for (size_t i = 0; i < count; i++) {
 		obs_data_t *array_obj = obs_data_array_item(macroArray, i);
-		macros.emplace_back();
-		macros.back().Load(array_obj);
+		macros.emplace_back(std::make_shared<Macro>());
+		macros.back()->Load(array_obj);
 		obs_data_release(array_obj);
 	}
 	obs_data_array_release(macroArray);
 
 	for (auto &m : macros) {
-		m.ResolveMacroRef();
+		m->ResolveMacroRef();
 	}
 }
 
@@ -478,11 +496,11 @@ bool SwitcherData::checkMacros()
 {
 	bool ret = false;
 	for (auto &m : macros) {
-		if (m.CeckMatch()) {
+		if (m->CeckMatch()) {
 			ret = true;
 			// This has to be performed here for now as actions are
 			// not performed immediately after checking conditions.
-			if (m.SwitchesScene()) {
+			if (m->SwitchesScene()) {
 				switcher->macroSceneSwitched = true;
 			}
 		}
@@ -492,12 +510,15 @@ bool SwitcherData::checkMacros()
 
 bool SwitcherData::runMacros()
 {
+	// TODO: Don't rely on creating a copy of each macro once new frontend
+	// events are available - see:
+	// https://github.com/obsproject/obs-studio/commit/feda1aaa283e8a99f6ba1159cfe6b9c1f2934a61
 	for (auto m : macros) {
-		if (m.Matched()) {
-			vblog(LOG_INFO, "running macro: %s", m.Name().c_str());
-			if (!m.PerformAction()) {
+		if (m->Matched()) {
+			vblog(LOG_INFO, "running macro: %s", m->Name().c_str());
+			if (!m->PerformAction()) {
 				blog(LOG_WARNING, "abort macro: %s",
-				     m.Name().c_str());
+				     m->Name().c_str());
 				return false;
 			}
 		}
@@ -508,8 +529,8 @@ bool SwitcherData::runMacros()
 Macro *GetMacroByName(const char *name)
 {
 	for (auto &m : switcher->macros) {
-		if (m.Name() == name) {
-			return &m;
+		if (m->Name() == name) {
+			return m.get();
 		}
 	}
 
@@ -570,3 +591,10 @@ void MacroRefAction::ResolveMacroRef()
 {
 	_macro.UpdateRef();
 }
+
+void MultiMacroRefAction::ResolveMacroRef()
+{
+	for (auto &m : _macros) {
+		m.UpdateRef();
+	}
+}

src/utility.cpp

@@ -12,6 +12,7 @@
 #include <QTimer>
 #include <QMessageBox>
 #include <QJsonDocument>
+#include <QSystemTrayIcon>
 #include <unordered_map>
 #include <regex>
 #include <set>
@@ -228,6 +229,16 @@ void clearLayout(QLayout *layout, int afterIdx)
 	}
 }
 
+void setLayoutVisible(QLayout *layout, bool visible)
+{
+	for (int i = 0; i < layout->count(); ++i) {
+		QWidget *widget = layout->itemAt(i)->widget();
+		if (widget != NULL) {
+			widget->setVisible(visible);
+		}
+	}
+}
+
 bool compareIgnoringLineEnding(QString &s1, QString &s2)
 {
 	// Let QT deal with different types of lineendings
@@ -443,6 +454,17 @@ bool DisplayMessage(const QString &msg, bool question)
 	return false;
 }
 
+void DisplayTrayMessage(const QString &title, const QString &msg)
+{
+	auto tray = reinterpret_cast<QSystemTrayIcon *>(
+		obs_frontend_get_system_tray());
+	if (!tray) {
+		return;
+	}
+
+	tray->showMessage(title, msg);
+}
+
 void addSelectionEntry(QComboBox *sel, const char *description, bool selectable,
 		       const char *tooltip)
 {
@@ -788,7 +810,8 @@ void populateSceneItemSelection(QComboBox *list, SceneSelection &s)
 {
 	std::set<QString> names;
 
-	if (s.GetType() == SceneSelectionType::CURRENT) {
+	if (s.GetType() == SceneSelectionType::CURRENT ||
+	    s.GetType() == SceneSelectionType::PREVIOUS) {
 		auto enumScenes = [](void *param, obs_source_t *source) {
 			if (!source) {
 				return true;
@@ -816,6 +839,36 @@ void populateSceneItemSelection(QComboBox *list, SceneSelection &s)
 	list->setCurrentIndex(0);
 }
 
+void populateSourceTypeSelection(QComboBox *list)
+{
+	std::set<QString> sourceTypeNames;
+	auto enumSourcesTypes = [](void *param, obs_source_t *source) {
+		if (!source) {
+			return true;
+		}
+		std::set<QString> *names =
+			reinterpret_cast<std::set<QString> *>(param);
+		if (obs_source_get_type(source) != OBS_SOURCE_TYPE_INPUT) {
+			return true;
+		}
+		names->insert(
+			obs_source_get_display_name(obs_source_get_id(source)));
+		return true;
+	};
+
+	obs_enum_sources(enumSourcesTypes, &sourceTypeNames);
+
+	for (auto &name : sourceTypeNames) {
+		if (!name.isEmpty()) {
+			list->addItem(name);
+		}
+	}
+
+	list->model()->sort(0);
+	addSelectionEntry(list, obs_module_text("AdvSceneSwitcher.selectItem"));
+	list->setCurrentIndex(0);
+}
+
 QMetaObject::Connection PulseWidget(QWidget *widget, QColor startColor,
 				    QColor endColor, QString specifier,
 				    bool once)