Switch to using process names for process condition and executable tab (#337)

Previously the process condition and executable tab were just reusing
the window title functionality.

.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,10 +1,6 @@
 name: build obs plugin
 
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    branches: [ master ]
+on: [push, pull_request, workflow_dispatch]
 
 env:
   PLUGIN_NAME: SceneSwitcher
@@ -115,7 +111,7 @@ jobs:
           path: ./nightly/*.pkg
   ubuntu64:
     name: 'Linux/Ubuntu 64-bit'
-    runs-on: [ubuntu-18.04]
+    runs-on: [ubuntu-latest]
     steps:
       - name: Checkout
         uses: actions/checkout@v2.3.4
@@ -181,7 +177,10 @@ jobs:
            libqt5svg5-dev \
            swig \
            libxss-dev \
-           libopencv-dev
+           libx11-xcb-dev \
+           libxcb-xfixes0-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

@@ -42,6 +42,7 @@ endif()
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/")
 include(GetGitRevisionDescription)
 get_git_head_revision(GIT_REFSPEC GIT_SHA1)
+git_describe(GIT_TAG)
 configure_file("${CMAKE_CURRENT_SOURCE_DIR}/cmake/version.cpp.in"
                "${CMAKE_CURRENT_BINARY_DIR}/src/version.cpp" @ONLY)
 
@@ -136,9 +137,20 @@ 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()
+  message (STATUS "WHAT THE FUCK IS GOING ON ${PROCPS_LIBRARY}")
+  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)
@@ -153,7 +165,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
@@ -218,6 +230,7 @@ set(advanced-scene-switcher_HEADERS
     src/headers/macro-action-scene-visibility.hpp
     src/headers/macro-action-source.hpp
     src/headers/macro-action-streaming.hpp
+    src/headers/macro-action-timer.hpp
     src/headers/macro-action-transition.hpp
     src/headers/macro-action-virtual-cam.hpp
     src/headers/macro-action-wait.hpp
@@ -308,6 +321,7 @@ set(advanced-scene-switcher_SOURCES
     src/macro-action-scene-visibility.cpp
     src/macro-action-source.cpp
     src/macro-action-streaming.cpp
+    src/macro-action-timer.cpp
     src/macro-action-transition.cpp
     src/macro-action-virtual-cam.cpp
     src/macro-action-wait.cpp
@@ -398,11 +412,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()

cmake/version.cpp.in

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

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)"
@@ -97,7 +98,8 @@ 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.notChanged="Scene has not changed"
-AdvSceneSwitcher.condition.scene.entry="{{sceneType}} {{scenes}}"
+AdvSceneSwitcher.condition.scene.waitForTransition="Wait for transition to complete"
+AdvSceneSwitcher.condition.scene.entry="{{sceneType}} {{scenes}} {{waitForTransition}}"
 AdvSceneSwitcher.condition.window="Window"
 AdvSceneSwitcher.condition.window.entry.line1="{{windows}} exist and ..."
 AdvSceneSwitcher.condition.window.entry.line2="... is {{fullscreen}} fullscreen {{maximized}} maximized {{focused}} focused {{windowFocusChanged}} foreground window changed"
@@ -118,10 +120,14 @@ 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."
 AdvSceneSwitcher.condition.video.objectScaleThreshold="Scale factor: "
 AdvSceneSwitcher.condition.video.objectScaleThresholdDescription="A lower scale factor will lead to more matches but higher CPU load."
+AdvSceneSwitcher.condition.video.minNeighborDescription="A higher minimum neighbors value will result in fewer but higher quality matches."
 AdvSceneSwitcher.condition.video.showMatch="Show match"
 AdvSceneSwitcher.condition.video.screenshotFail="Failed to get screenshot of source!"
 AdvSceneSwitcher.condition.video.patternMatchFail="Pattern was not found!"
@@ -136,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"
@@ -150,9 +158,11 @@ AdvSceneSwitcher.condition.pluginState="Plugin state"
 AdvSceneSwitcher.condition.pluginState.state.sceneSwitched="Automated scene change was triggered in this interval"
 AdvSceneSwitcher.condition.pluginState.entry="{{condition}}"
 AdvSceneSwitcher.condition.timer="Timer"
+AdvSceneSwitcher.condition.timer.pause="Pause"
+AdvSceneSwitcher.condition.timer.continue="Continue"
 AdvSceneSwitcher.condition.timer.entry.line1="{{duration}} have passed"
 AdvSceneSwitcher.condition.timer.entry.line2="Time remaining: {{remaining}} seconds"
-AdvSceneSwitcher.condition.timer.entry.line3="{{reset}} {{autoReset}} Automatically reset timer after duration was reached"
+AdvSceneSwitcher.condition.timer.entry.line3="{{pauseContinue}} {{reset}} {{saveRemaining}} Save time remaining {{autoReset}} Automatically reset timer after duration was reached"
 AdvSceneSwitcher.condition.timer.reset="Reset"
 AdvSceneSwitcher.condition.macro="Macro"
 AdvSceneSwitcher.condition.macro.type.count="Count"
@@ -208,7 +218,7 @@ AdvSceneSwitcher.condition.date.state.after="After"
 AdvSceneSwitcher.condition.date.state.before="Before"
 AdvSceneSwitcher.condition.date.state.between="Between"
 AdvSceneSwitcher.condition.date.entry.line1="{{condition}} {{dateTime}} {{dateTime2}} {{ignoreDate}} Ignore date component {{ignoreTime}} Ignore time component"
-AdvSceneSwitcher.condition.date.entry.line2="{{repeat}} Reschedule {{duration}} later when matching"
+AdvSceneSwitcher.condition.date.entry.line2="{{repeat}} Repeat every {{duration}} on date match"
 AdvSceneSwitcher.condition.sceneTransform="Scene item transform"
 AdvSceneSwitcher.condition.sceneTransform.getTransform="Get transform"
 AdvSceneSwitcher.condition.sceneTransform.regex="Use regular expressions"
@@ -329,6 +339,12 @@ AdvSceneSwitcher.action.SceneSwap.entry="Swap preview and program scene in studi
 AdvSceneSwitcher.action.transition="Transition"
 AdvSceneSwitcher.action.transition.entry.line1="{{setType}}Set transition type to {{transitions}}"
 AdvSceneSwitcher.action.transition.entry.line2="{{setDuration}}Set transition duration to {{duration}}seconds"
+AdvSceneSwitcher.action.timer="Timer"
+AdvSceneSwitcher.action.timer.type.pause="Pause"
+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}}"
 
 ; Transition Tab
 AdvSceneSwitcher.transitionTab.title="Transition"
@@ -603,6 +619,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

@@ -258,13 +258,6 @@
                 </item>
                </layout>
               </item>
-              <item>
-               <widget class="Line" name="line_6">
-                <property name="orientation">
-                 <enum>Qt::Horizontal</enum>
-                </property>
-               </widget>
-              </item>
               <item>
                <layout class="QHBoxLayout" name="horizontalLayout_52">
                 <item>
@@ -313,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>
@@ -364,19 +381,6 @@
                   <item>
                    <widget class="QListWidget" name="priorityList"/>
                   </item>
-                  <item>
-                   <spacer name="horizontalSpacer_30">
-                    <property name="orientation">
-                     <enum>Qt::Horizontal</enum>
-                    </property>
-                    <property name="sizeHint" stdset="0">
-                     <size>
-                      <width>40</width>
-                      <height>20</height>
-                     </size>
-                    </property>
-                   </spacer>
-                  </item>
                  </layout>
                 </item>
                </layout>

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>
@@ -36,9 +37,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 +112,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 +164,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);
@@ -232,12 +228,17 @@ void SwitcherData::Thread()
 			}
 		}
 
-		// After this point we will call frontend functions
+		// After this point we will call frontend functions like
 		// obs_frontend_set_current_scene() and
 		// obs_frontend_set_current_transition()
 		//
 		// During this time SaveSceneSwitcher() could be called
-		// leading to a deadlock, so we have to unlock()
+		// leading to a deadlock with the frontend function being stuck
+		// in QMetaObject::invokeMethod() holding the mutex and
+		// OBS being stuck in SaveSceneSwitcher().
+		//
+		// So we have to unlock() risking race conditions as these are
+		// less frequent than the above described deadlock
 		lock.unlock();
 
 		if (match) {
@@ -410,6 +411,12 @@ 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()
@@ -436,6 +443,12 @@ void SwitcherData::Stop()
 
 	server.stop();
 	client.disconnect();
+
+	if (showSystemTrayNotifications) {
+		DisplayTrayMessage(
+			obs_module_text("AdvSceneSwitcher.pluginName"),
+			obs_module_text("AdvSceneSwitcher.stopped"));
+	}
 }
 
 void SwitcherData::setWaitScene()
@@ -553,6 +566,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()
@@ -592,6 +617,12 @@ 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;
 	}
@@ -599,6 +630,7 @@ static void OBSEvent(enum obs_frontend_event event, void *switcher)
 
 extern "C" void InitSceneSwitcher()
 {
+	blog(LOG_INFO, "version: %s", g_GIT_TAG);
 	blog(LOG_INFO, "version: %s", g_GIT_SHA1);
 
 	QAction *action = (QAction *)obs_frontend_add_tools_menu_qaction(

src/duration-control.cpp

@@ -46,6 +46,13 @@ double Duration::TimeRemaining()
 	return (seconds * 1000 - runTime.count()) / 1000.;
 }
 
+void Duration::SetTimeRemaining(double remaining)
+{
+	long long msPassed = (seconds - remaining) * 1000;
+	_startTime = std::chrono::high_resolution_clock::now() -
+		     std::chrono::milliseconds(msPassed);
+}
+
 void Duration::Reset()
 {
 	_startTime = {};

src/general.cpp

@@ -210,6 +210,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 +512,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 +585,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 +813,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) {
@@ -887,4 +902,6 @@ void AdvSceneSwitcher::setupGeneralTab()
 	QTimer *statusTimer = new QTimer(this);
 	connect(statusTimer, SIGNAL(timeout()), this, SLOT(updateStatus()));
 	statusTimer->start(1000);
+
+	setWindowTitle(windowTitle() + " - " + g_GIT_TAG);
 }

src/headers/advanced-scene-switcher.hpp

@@ -52,6 +52,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 ConnectControlSignals(MacroActionEdit *);
 	void ConnectControlSignals(MacroConditionEdit *);
 	void SwapActions(Macro *m, int pos1, int pos2);
@@ -162,6 +164,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/duration-control.hpp

@@ -22,6 +22,7 @@ public:
 
 	bool DurationReached();
 	double TimeRemaining();
+	void SetTimeRemaining(double);
 	void Reset();
 	std::string ToString();
 

src/headers/macro-action-timer.hpp

@@ -0,0 +1,72 @@
+#pragma once
+#include "macro-action-edit.hpp"
+#include "duration-control.hpp"
+#include "macro-selection.hpp"
+
+#include <QDoubleSpinBox>
+#include <QHBoxLayout>
+
+enum class TimerAction {
+	PAUSE,
+	CONTINUE,
+	RESET,
+	SET_TIME_REMAINING,
+};
+
+class MacroActionTimer : public MacroRefAction {
+public:
+	bool PerformAction();
+	void LogAction();
+	bool Save(obs_data_t *obj);
+	bool Load(obs_data_t *obj);
+	std::string GetShortDesc();
+	std::string GetId() { return id; };
+	static std::shared_ptr<MacroAction> Create()
+	{
+		return std::make_shared<MacroActionTimer>();
+	}
+	Duration _duration;
+	TimerAction _actionType = TimerAction::PAUSE;
+
+private:
+	static bool _registered;
+	static const std::string id;
+};
+
+class MacroActionTimerEdit : public QWidget {
+	Q_OBJECT
+
+public:
+	MacroActionTimerEdit(
+		QWidget *parent,
+		std::shared_ptr<MacroActionTimer> entryData = nullptr);
+	void UpdateEntryData();
+	static QWidget *Create(QWidget *parent,
+			       std::shared_ptr<MacroAction> action)
+	{
+		return new MacroActionTimerEdit(
+			parent,
+			std::dynamic_pointer_cast<MacroActionTimer>(action));
+	}
+
+private slots:
+	void MacroChanged(const QString &text);
+	void MacroRemove(const QString &name);
+	void DurationChanged(double value);
+	void DurationUnitChanged(DurationUnit unit);
+	void ActionTypeChanged(int value);
+signals:
+	void HeaderInfoChanged(const QString &);
+
+protected:
+	void SetWidgetVisibility();
+
+	MacroSelection *_macros;
+	DurationSelection *_duration;
+	QComboBox *_timerAction;
+	std::shared_ptr<MacroActionTimer> _entryData;
+
+private:
+	QHBoxLayout *_mainLayout;
+	bool _loading = true;
+};

src/headers/macro-condition-scene.hpp

@@ -4,6 +4,7 @@
 
 #include <QWidget>
 #include <QComboBox>
+#include <QCheckBox>
 
 enum class SceneType {
 	CURRENT,
@@ -24,6 +25,7 @@ public:
 		return std::make_shared<MacroConditionScene>();
 	}
 
+	bool _waitForTransition = false;
 	SceneSelection _scene;
 	SceneType _type;
 
@@ -52,12 +54,14 @@ public:
 private slots:
 	void SceneChanged(const SceneSelection &);
 	void TypeChanged(int value);
+	void WaitForTransitionChanged(int state);
 signals:
 	void HeaderInfoChanged(const QString &);
 
 protected:
 	SceneSelectionWidget *_scenes;
 	QComboBox *_sceneType;
+	QCheckBox *_waitForTransition;
 	std::shared_ptr<MacroConditionScene> _entryData;
 
 private:

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-timer.hpp

@@ -16,8 +16,14 @@ public:
 	{
 		return std::make_shared<MacroConditionTimer>();
 	}
+	void Pause();
+	void Continue();
+	void Reset();
 
 	Duration _duration;
+	bool _paused = false;
+	bool _saveRemaining = false;
+	double _remaining = 0.;
 	bool _oneshot = false;
 
 private:
@@ -44,14 +50,20 @@ public:
 private slots:
 	void DurationChanged(double seconds);
 	void DurationUnitChanged(DurationUnit unit);
+	void SaveRemainingChanged(int state);
 	void AutoResetChanged(int state);
+	void PauseContinueClicked();
 	void ResetClicked();
 	void UpdateTimeRemaining();
 
 protected:
+	void SetPauseContinueButtonLabel();
+
 	DurationSelection *_duration;
 	QCheckBox *_autoReset;
+	QCheckBox *_saveRemaining;
 	QPushButton *_reset;
+	QPushButton *_pauseConinue;
 	QLabel *_remaining;
 	std::shared_ptr<MacroConditionTimer> _entryData;
 

src/headers/macro-condition-video.hpp

@@ -20,6 +20,12 @@ enum class VideoCondition {
 	OBJECT,
 };
 
+struct PatternMatchData {
+	cv::Mat4b rgbaPattern;
+	cv::Mat3b rgbPattern;
+	cv::Mat1b mask;
+};
+
 constexpr int minMinNeighbors = 3;
 constexpr int maxMinNeighbors = 6;
 
@@ -44,6 +50,9 @@ public:
 	OBSWeakSource _videoSource;
 	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;
 	double _scaleFactor = 1.1;
@@ -57,6 +66,7 @@ public:
 	int _throttleCount = 3;
 
 private:
+	bool OutputChanged();
 	bool ScreenshotContainsPattern();
 	bool ScreenshotContainsObject();
 	bool Compare();
@@ -119,7 +129,9 @@ private slots:
 	void ConditionChanged(int cond);
 	void ImagePathChanged(const QString &text);
 	void ImageBrowseButtonClicked();
+	void UsePatternForChangedCheckChanged(int value);
 	void PatternThresholdChanged(double);
+	void UseAlphaAsMaskChanged(int value);
 
 	void ModelPathChanged(const QString &text);
 	void ObjectScaleThresholdChanged(double);
@@ -139,14 +151,17 @@ protected:
 	QComboBox *_videoSelection;
 	QComboBox *_condition;
 
+	QCheckBox *_usePatternForChangedCheck;
 	FileSelection *_imagePath;
 	ThresholdSlider *_patternThreshold;
+	QCheckBox *_useAlphaAsMask;
 
 	FileSelection *_modelDataPath;
 	QHBoxLayout *_modelPathLayout;
 	ThresholdSlider *_objectScaleThreshold;
 	QHBoxLayout *_neighborsControlLayout;
 	QSpinBox *_minNeighbors;
+	QLabel *_minNeighborsDescription;
 	QHBoxLayout *_minSizeControlLayout;
 	QSpinBox *_minSizeX;
 	QSpinBox *_minSizeY;

src/headers/macro-segment.hpp

@@ -30,6 +30,7 @@ public:
 	// Use this function to avoid accidental edits when scrolling through
 	// list of actions and conditions
 	void SetFocusPolicyOfWidgets();
+	void SetCollapsed(bool collapsed);
 
 protected slots:
 	void HeaderInfoChanged(const QString &);

src/headers/scene-trigger.hpp

@@ -8,6 +8,7 @@
 #pragma once
 
 #include "switch-generic.hpp"
+#include "duration-control.hpp"
 
 enum class sceneTriggerType {
 	NONE = 0,
@@ -43,7 +44,7 @@ struct SceneTrigger : SceneSwitcherEntry {
 	static bool pause;
 	sceneTriggerType triggerType = sceneTriggerType::NONE;
 	sceneTriggerAction triggerAction = sceneTriggerAction::NONE;
-	double duration = 0;
+	Duration duration;
 	OBSWeakSource audioSource = nullptr;
 
 	const char *getType() { return "trigger"; }
@@ -70,13 +71,14 @@ public:
 private slots:
 	void TriggerTypeChanged(int index);
 	void TriggerActionChanged(int index);
-	void DurationChanged(double dur);
+	void DurationChanged(double seconds);
+	void DurationUnitChanged(DurationUnit unit);
 	void AudioSourceChanged(const QString &text);
 
 private:
 	QComboBox *triggers;
 	QComboBox *actions;
-	QDoubleSpinBox *duration;
+	DurationSelection *duration;
 	QComboBox *audioSources;
 
 	SceneTrigger *switchData;

src/headers/section.hpp

@@ -16,6 +16,7 @@ public:
 
 	void SetContent(QWidget *w, bool collapsed = true);
 	void AddHeaderWidget(QWidget *);
+	void SetCollapsed(bool);
 
 protected:
 	bool eventFilter(QObject *obj, QEvent *event) override;

src/headers/switcher-data-structs.hpp

@@ -70,6 +70,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 +82,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;

src/headers/utility.hpp

@@ -44,7 +44,7 @@ void placeWidgets(std::string text, QBoxLayout *layout,
 		  std::unordered_map<std::string, QWidget *> placeholders,
 		  bool addStretch = true);
 void deleteLayoutItem(QLayoutItem *item);
-void clearLayout(QLayout *layout);
+void clearLayout(QLayout *layout, int afterIdx = 0);
 QMetaObject::Connection PulseWidget(QWidget *widget, QColor startColor,
 				    QColor = QColor(0, 0, 0, 0),
 				    QString specifier = "QLabel ",
@@ -55,6 +55,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,

src/headers/version.h

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

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-edit.cpp

@@ -152,12 +152,8 @@ void AdvSceneSwitcher::AddMacroAction(int idx)
 	}
 	macro->UpdateActionIndices();
 
-	// All entry pointers in existing edit widgets after the new entry will
-	// be invalidated by adding the new entry so we have to recreate them
-	// and because I am lazy I am recreating every widget.
-	//
-	// If performance should become a concern this has to be revisited.
-	SetEditMacro(*macro);
+	clearLayout(ui->macroEditActionLayout, idx);
+	PopulateMacroActions(*macro, idx);
 	HighlightAction(idx);
 }
 
@@ -189,12 +185,8 @@ void AdvSceneSwitcher::RemoveMacroAction(int idx)
 	switcher->macroWaitCv.notify_one();
 	macro->UpdateActionIndices();
 
-	// All entry pointers in existing edit widgets after the new entry will
-	// be invalidated by adding the new entry so we have to recreate them
-	// and because I am lazy I am recreating every widget.
-	//
-	// If performance should become a concern this has to be revisited.
-	SetEditMacro(*macro);
+	clearLayout(ui->macroEditActionLayout, idx);
+	PopulateMacroActions(*macro, idx);
 }
 
 void AdvSceneSwitcher::on_actionRemove_clicked()

src/macro-action-timer.cpp

@@ -0,0 +1,228 @@
+#include "headers/macro-action-timer.hpp"
+#include "headers/macro-condition-timer.hpp"
+#include "headers/advanced-scene-switcher.hpp"
+#include "headers/utility.hpp"
+
+#include <random>
+
+const std::string MacroActionTimer::id = "timer";
+
+bool MacroActionTimer::_registered = MacroActionFactory::Register(
+	MacroActionTimer::id,
+	{MacroActionTimer::Create, MacroActionTimerEdit::Create,
+	 "AdvSceneSwitcher.action.Timer"});
+
+static std::map<TimerAction, std::string> timerActions = {
+	{TimerAction::PAUSE, "AdvSceneSwitcher.action.timer.type.pause"},
+	{TimerAction::CONTINUE, "AdvSceneSwitcher.action.timer.type.continue"},
+	{TimerAction::RESET, "AdvSceneSwitcher.action.timer.type.reset"},
+	{TimerAction::SET_TIME_REMAINING,
+	 "AdvSceneSwitcher.action.timer.type.setTimeRemaining"},
+};
+
+bool MacroActionTimer::PerformAction()
+{
+	if (!_macro.get()) {
+		return true;
+	}
+	for (auto c : _macro->Conditions()) {
+		if (c->GetId() != "timer") {
+			continue;
+		}
+		auto timerCondition =
+			dynamic_cast<MacroConditionTimer *>(c.get());
+		if (!timerCondition) {
+			continue;
+		}
+
+		switch (_actionType) {
+		case TimerAction::PAUSE:
+			timerCondition->Pause();
+			break;
+		case TimerAction::CONTINUE:
+			timerCondition->Continue();
+			break;
+		case TimerAction::RESET:
+			timerCondition->Reset();
+			break;
+		case TimerAction::SET_TIME_REMAINING:
+			timerCondition->_duration.SetTimeRemaining(
+				_duration.seconds);
+			break;
+		default:
+			break;
+		}
+	}
+	return true;
+}
+
+void MacroActionTimer::LogAction()
+{
+	if (!_macro.get()) {
+		return;
+	}
+	switch (_actionType) {
+	case TimerAction::PAUSE:
+		vblog(LOG_INFO, "paused timers on \"%s\"",
+		      _macro->Name().c_str());
+		break;
+	case TimerAction::CONTINUE:
+		vblog(LOG_INFO, "continued timers on \"%s\"",
+		      _macro->Name().c_str());
+		break;
+	case TimerAction::RESET:
+		vblog(LOG_INFO, "reset timers on \"%s\"",
+		      _macro->Name().c_str());
+		break;
+	case TimerAction::SET_TIME_REMAINING:
+		vblog(LOG_INFO,
+		      "set time remaining of timers on \"%s\" to \"%s\"",
+		      _macro->Name().c_str(), _duration.ToString().c_str());
+		break;
+	default:
+		break;
+	}
+}
+
+bool MacroActionTimer::Save(obs_data_t *obj)
+{
+	MacroAction::Save(obj);
+	_macro.Save(obj);
+	_duration.Save(obj);
+	obs_data_set_int(obj, "actionType", static_cast<int>(_actionType));
+	return true;
+}
+
+bool MacroActionTimer::Load(obs_data_t *obj)
+{
+	MacroAction::Load(obj);
+	_macro.Load(obj);
+	_duration.Load(obj);
+	_actionType =
+		static_cast<TimerAction>(obs_data_get_int(obj, "actionType"));
+	return true;
+}
+
+std::string MacroActionTimer::GetShortDesc()
+{
+	if (_macro.get()) {
+		return _macro->Name();
+	}
+	return "";
+}
+
+static inline void populateTypeSelection(QComboBox *list)
+{
+	for (auto entry : timerActions) {
+		list->addItem(obs_module_text(entry.second.c_str()));
+	}
+}
+
+MacroActionTimerEdit::MacroActionTimerEdit(
+	QWidget *parent, std::shared_ptr<MacroActionTimer> entryData)
+	: QWidget(parent)
+{
+	_macros = new MacroSelection(parent);
+	_duration = new DurationSelection();
+	_timerAction = new QComboBox();
+
+	populateTypeSelection(_timerAction);
+
+	QWidget::connect(_macros, SIGNAL(currentTextChanged(const QString &)),
+			 this, SLOT(MacroChanged(const QString &)));
+	QWidget::connect(parent, SIGNAL(MacroRemoved(const QString &)), this,
+			 SLOT(MacroRemove(const QString &)));
+	QWidget::connect(_duration, SIGNAL(DurationChanged(double)), this,
+			 SLOT(DurationChanged(double)));
+	QWidget::connect(_duration, SIGNAL(UnitChanged(DurationUnit)), this,
+			 SLOT(DurationUnitChanged(DurationUnit)));
+	QWidget::connect(_timerAction, SIGNAL(currentIndexChanged(int)), this,
+			 SLOT(ActionTypeChanged(int)));
+
+	_mainLayout = new QHBoxLayout;
+	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
+		{"{{macros}}", _macros},
+		{"{{duration}}", _duration},
+		{"{{timerAction}}", _timerAction},
+	};
+	placeWidgets(obs_module_text("AdvSceneSwitcher.action.timer.entry"),
+		     _mainLayout, widgetPlaceholders);
+	setLayout(_mainLayout);
+
+	_entryData = entryData;
+	UpdateEntryData();
+	_loading = false;
+}
+
+void MacroActionTimerEdit::UpdateEntryData()
+{
+	if (!_entryData) {
+		return;
+	}
+
+	_macros->SetCurrentMacro(_entryData->_macro.get());
+	_duration->SetDuration(_entryData->_duration);
+	_timerAction->setCurrentIndex(
+		static_cast<int>(_entryData->_actionType));
+	SetWidgetVisibility();
+}
+
+void MacroActionTimerEdit::ActionTypeChanged(int value)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_actionType = static_cast<TimerAction>(value);
+	SetWidgetVisibility();
+}
+
+void MacroActionTimerEdit::SetWidgetVisibility()
+{
+	if (!_entryData) {
+		return;
+	}
+	_duration->setVisible(_entryData->_actionType ==
+			      TimerAction::SET_TIME_REMAINING);
+	adjustSize();
+}
+
+void MacroActionTimerEdit::DurationChanged(double seconds)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_duration.seconds = seconds;
+}
+
+void MacroActionTimerEdit::DurationUnitChanged(DurationUnit unit)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_duration.displayUnit = unit;
+}
+
+void MacroActionTimerEdit::MacroChanged(const QString &text)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_macro.UpdateRef(text);
+	emit HeaderInfoChanged(
+		QString::fromStdString(_entryData->GetShortDesc()));
+}
+
+void MacroActionTimerEdit::MacroRemove(const QString &)
+{
+	if (_entryData) {
+		_entryData->_macro.UpdateRef();
+	}
+}

src/macro-condition-edit.cpp

@@ -276,12 +276,8 @@ void AdvSceneSwitcher::AddMacroCondition(int idx)
 	(*cond)->SetLogicType(logic);
 	macro->UpdateConditionIndices();
 
-	// All entry pointers in existing edit widgets after the new entry will
-	// be invalidated by adding the new entry so we have to recreate them
-	// and because I am lazy I am recreating every widget.
-	//
-	// If performance should become a concern this has to be revisited.
-	SetEditMacro(*macro);
+	clearLayout(ui->macroEditConditionLayout, idx);
+	PopulateMacroConditions(*macro, idx);
 	HighlightCondition(idx);
 }
 
@@ -311,21 +307,13 @@ void AdvSceneSwitcher::RemoveMacroCondition(int idx)
 	macro->Conditions().erase(macro->Conditions().begin() + idx);
 	macro->UpdateConditionIndices();
 
-	if (macro->Conditions().size() == 0) {
-		ui->macroEditConditionHelp->setVisible(true);
-	}
-
 	if (idx == 0 && macro->Conditions().size() > 0) {
 		auto newRoot = macro->Conditions().at(0);
 		newRoot->SetLogicType(LogicType::ROOT_NONE);
 	}
 
-	// All entry pointers in existing edit widgets after the new entry will
-	// be invalidated by adding the new entry so we have to recreate them
-	// and because I am lazy I am recreating every widget.
-	//
-	// If performance should become a concern this has to be revisited.
-	SetEditMacro(*macro);
+	clearLayout(ui->macroEditConditionLayout, idx);
+	PopulateMacroConditions(*macro, idx);
 }
 
 void AdvSceneSwitcher::on_conditionRemove_clicked()

src/macro-condition-scene.cpp

@@ -28,7 +28,18 @@ bool MacroConditionScene::CheckCondition()
 
 	switch (_type) {
 	case SceneType::CURRENT:
-		return switcher->currentScene == _scene.GetScene(false);
+		if (_waitForTransition) {
+			return switcher->currentScene == _scene.GetScene(false);
+		} else {
+
+			bool match = false;
+			auto current = obs_frontend_get_current_scene();
+			auto weak = obs_source_get_weak_source(current);
+			match = weak == _scene.GetScene(false);
+			obs_weak_source_release(weak);
+			obs_source_release(current);
+			return match;
+		}
 	case SceneType::PREVIOUS:
 		return switcher->previousScene == _scene.GetScene(false);
 	case SceneType::CHANGED:
@@ -47,6 +58,7 @@ bool MacroConditionScene::Save(obs_data_t *obj)
 	MacroCondition::Save(obj);
 	_scene.Save(obj);
 	obs_data_set_int(obj, "type", static_cast<int>(_type));
+	obs_data_set_bool(obj, "waitForTransition", _waitForTransition);
 	return true;
 }
 
@@ -55,6 +67,12 @@ bool MacroConditionScene::Load(obs_data_t *obj)
 	MacroCondition::Load(obj);
 	_scene.Load(obj);
 	_type = static_cast<SceneType>(obs_data_get_int(obj, "type"));
+	if (!obs_data_has_user_value(obj, "waitForTransition")) {
+		_waitForTransition = true;
+	} else {
+		_waitForTransition =
+			obs_data_get_bool(obj, "waitForTransition");
+	}
 	return true;
 }
 
@@ -76,11 +94,15 @@ MacroConditionSceneEdit::MacroConditionSceneEdit(
 {
 	_scenes = new SceneSelectionWidget(window(), false, false, false);
 	_sceneType = new QComboBox();
+	_waitForTransition = new QCheckBox(obs_module_text(
+		"AdvSceneSwitcher.condition.scene.waitForTransition"));
 
 	QWidget::connect(_scenes, SIGNAL(SceneChanged(const SceneSelection &)),
 			 this, SLOT(SceneChanged(const SceneSelection &)));
 	QWidget::connect(_sceneType, SIGNAL(currentIndexChanged(int)), this,
 			 SLOT(TypeChanged(int)));
+	QWidget::connect(_waitForTransition, SIGNAL(stateChanged(int)), this,
+			 SLOT(WaitForTransitionChanged(int)));
 
 	populateTypeSelection(_sceneType);
 
@@ -88,6 +110,7 @@ MacroConditionSceneEdit::MacroConditionSceneEdit(
 	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
 		{"{{scenes}}", _scenes},
 		{"{{sceneType}}", _sceneType},
+		{"{{waitForTransition}}", _waitForTransition},
 	};
 	placeWidgets(obs_module_text("AdvSceneSwitcher.condition.scene.entry"),
 		     mainLayout, widgetPlaceholders);
@@ -121,10 +144,21 @@ void MacroConditionSceneEdit::TypeChanged(int value)
 	SetWidgetVisibility();
 }
 
+void MacroConditionSceneEdit::WaitForTransitionChanged(int state)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_waitForTransition = state;
+}
+
 void MacroConditionSceneEdit::SetWidgetVisibility()
 {
 	_scenes->setVisible(_entryData->_type == SceneType::CURRENT ||
 			    _entryData->_type == SceneType::PREVIOUS);
+	_waitForTransition->setVisible(_entryData->_type == SceneType::CURRENT);
 }
 
 void MacroConditionSceneEdit::UpdateEntryData()
@@ -135,5 +169,6 @@ void MacroConditionSceneEdit::UpdateEntryData()
 
 	_scenes->SetScene(_entryData->_scene);
 	_sceneType->setCurrentIndex(static_cast<int>(_entryData->_type));
+	_waitForTransition->setChecked(_entryData->_waitForTransition);
 	SetWidgetVisibility();
 }

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-timer.cpp

@@ -12,6 +12,9 @@ bool MacroConditionTimer::_registered = MacroConditionFactory::Register(
 
 bool MacroConditionTimer::CheckCondition()
 {
+	if (_paused) {
+		return _remaining == 0.;
+	}
 	if (_duration.DurationReached()) {
 		if (!_oneshot) {
 			_duration.Reset();
@@ -25,6 +28,16 @@ bool MacroConditionTimer::Save(obs_data_t *obj)
 {
 	MacroCondition::Save(obj);
 	_duration.Save(obj);
+	if (!_paused) {
+		_remaining = _duration.TimeRemaining();
+	}
+	if (_saveRemaining) {
+		obs_data_set_double(obj, "remaining", _remaining);
+	} else {
+		obs_data_set_double(obj, "remaining", _duration.seconds);
+	}
+	obs_data_set_bool(obj, "saveRemaining", _saveRemaining);
+	obs_data_set_bool(obj, "paused", _paused);
 	obs_data_set_bool(obj, "oneshot", _oneshot);
 	return true;
 }
@@ -33,20 +46,49 @@ bool MacroConditionTimer::Load(obs_data_t *obj)
 {
 	MacroCondition::Load(obj);
 	_duration.Load(obj);
+	_remaining = obs_data_get_double(obj, "remaining");
+	_paused = obs_data_get_bool(obj, "paused");
+	_saveRemaining = obs_data_get_bool(obj, "saveRemaining");
 	if (!obs_data_has_user_value(obj, "oneshot")) {
 		_oneshot = false;
 	} else {
 		_oneshot = obs_data_get_bool(obj, "oneshot");
 	}
+	_duration.SetTimeRemaining(_remaining);
 	return true;
 }
 
+void MacroConditionTimer::Pause()
+{
+	if (!_paused) {
+		_paused = true;
+		_remaining = _duration.TimeRemaining();
+	}
+}
+
+void MacroConditionTimer::Continue()
+{
+	if (_paused) {
+		_paused = false;
+		_duration.SetTimeRemaining(_remaining);
+	}
+}
+
+void MacroConditionTimer::Reset()
+{
+	_remaining = _duration.seconds;
+	_duration.Reset();
+}
+
 MacroConditionTimerEdit::MacroConditionTimerEdit(
 	QWidget *parent, std::shared_ptr<MacroConditionTimer> entryData)
 	: QWidget(parent)
 {
 	_duration = new DurationSelection();
 	_autoReset = new QCheckBox();
+	_saveRemaining = new QCheckBox();
+	_pauseConinue = new QPushButton(
+		obs_module_text("AdvSceneSwitcher.condition.timer.pause"));
 	_reset = new QPushButton(
 		obs_module_text("AdvSceneSwitcher.condition.timer.reset"));
 	_remaining = new QLabel();
@@ -55,16 +97,22 @@ MacroConditionTimerEdit::MacroConditionTimerEdit(
 			 SLOT(DurationChanged(double)));
 	QWidget::connect(_duration, SIGNAL(UnitChanged(DurationUnit)), this,
 			 SLOT(DurationUnitChanged(DurationUnit)));
+	QWidget::connect(_pauseConinue, SIGNAL(clicked()), this,
+			 SLOT(PauseContinueClicked()));
 	QWidget::connect(_reset, SIGNAL(clicked()), this, SLOT(ResetClicked()));
 	QWidget::connect(_autoReset, SIGNAL(stateChanged(int)), this,
 			 SLOT(AutoResetChanged(int)));
+	QWidget::connect(_saveRemaining, SIGNAL(stateChanged(int)), this,
+			 SLOT(SaveRemainingChanged(int)));
 
 	auto line1Layout = new QHBoxLayout;
 	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
 		{"{{duration}}", _duration},
 		{"{{autoReset}}", _autoReset},
 		{"{{remaining}}", _remaining},
+		{"{{pauseContinue}}", _pauseConinue},
 		{"{{reset}}", _reset},
+		{"{{saveRemaining}}", _saveRemaining},
 	};
 	placeWidgets(
 		obs_module_text("AdvSceneSwitcher.condition.timer.entry.line1"),
@@ -112,6 +160,16 @@ void MacroConditionTimerEdit::DurationUnitChanged(DurationUnit unit)
 	_entryData->_duration.displayUnit = unit;
 }
 
+void MacroConditionTimerEdit::SaveRemainingChanged(int state)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_saveRemaining = state;
+}
+
 void MacroConditionTimerEdit::AutoResetChanged(int state)
 {
 	if (_loading || !_entryData) {
@@ -122,6 +180,23 @@ void MacroConditionTimerEdit::AutoResetChanged(int state)
 	_entryData->_oneshot = !state;
 }
 
+void MacroConditionTimerEdit::PauseContinueClicked()
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	if (_entryData->_paused) {
+		timer.start(1000);
+		_entryData->Continue();
+	} else {
+		_entryData->Pause();
+		timer.stop();
+	}
+	SetPauseContinueButtonLabel();
+}
+
 void MacroConditionTimerEdit::ResetClicked()
 {
 	if (_loading || !_entryData) {
@@ -129,7 +204,7 @@ void MacroConditionTimerEdit::ResetClicked()
 	}
 
 	std::lock_guard<std::mutex> lock(switcher->m);
-	_entryData->_duration.Reset();
+	_entryData->Reset();
 }
 
 void MacroConditionTimerEdit::UpdateTimeRemaining()
@@ -138,8 +213,28 @@ void MacroConditionTimerEdit::UpdateTimeRemaining()
 		_remaining->setText("-");
 		return;
 	}
-	_remaining->setText(
-		QString::number(_entryData->_duration.TimeRemaining()));
+
+	if (_entryData->_paused) {
+		_remaining->setText(QString::number(_entryData->_remaining));
+	} else {
+		_remaining->setText(
+			QString::number(_entryData->_duration.TimeRemaining()));
+	}
+}
+
+void MacroConditionTimerEdit::SetPauseContinueButtonLabel()
+{
+	if (!_entryData) {
+		return;
+	}
+
+	if (_entryData->_paused) {
+		_pauseConinue->setText(obs_module_text(
+			"AdvSceneSwitcher.condition.timer.continue"));
+	} else {
+		_pauseConinue->setText(obs_module_text(
+			"AdvSceneSwitcher.condition.timer.pause"));
+	}
 }
 
 void MacroConditionTimerEdit::UpdateEntryData()
@@ -150,4 +245,6 @@ void MacroConditionTimerEdit::UpdateEntryData()
 
 	_duration->SetDuration(_entryData->_duration);
 	_autoReset->setChecked(!_entryData->_oneshot);
+	_saveRemaining->setChecked(_entryData->_saveRemaining);
+	SetPauseContinueButtonLabel();
 }

src/macro-condition-video.cpp

@@ -35,7 +35,12 @@ static std::map<VideoCondition, std::string> conditionTypes = {
 cv::CascadeClassifier initObjectCascade(std::string &path)
 {
 	cv::CascadeClassifier cascade;
-	cascade.load(path);
+	try {
+		cascade.load(path);
+	} catch (...) {
+		blog(LOG_WARNING, "failed to load model data \"%s\"",
+		     path.c_str());
+	}
 	return cascade;
 }
 
@@ -94,7 +99,10 @@ 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());
 	obs_data_set_double(obj, "scaleFactor", _scaleFactor);
 	obs_data_set_int(obj, "minNeighbors", _minNeighbors);
@@ -126,14 +134,17 @@ 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");
 	_scaleFactor = obs_data_get_double(obj, "scaleFactor");
 	if (!isScaleFactorValid(_scaleFactor)) {
 		_scaleFactor = 1.1;
 	}
 	_minNeighbors = obs_data_get_int(obj, "minNeighbors");
-	if (!isMinNeighborsValid(_scaleFactor)) {
+	if (!isMinNeighborsValid(_minNeighbors)) {
 		_minNeighbors = minMinNeighbors;
 	}
 	_minSizeX = obs_data_get_int(obj, "minSizeX");
@@ -169,32 +180,7 @@ void MacroConditionVideo::GetScreenshot()
 	obs_source_release(source);
 }
 
-bool MacroConditionVideo::LoadImageFromFile()
-{
-	if (!_matchImage.load(QString::fromStdString(_file))) {
-		blog(LOG_WARNING, "Cannot load image data from file '%s'",
-		     _file.c_str());
-		return false;
-	}
-	_matchImage =
-		_matchImage.convertToFormat(QImage::Format::Format_RGBX8888);
-	return true;
-}
-
-bool MacroConditionVideo::LoadModelData(std::string &path)
-{
-	_modelDataPath = path;
-	try {
-		_objectCascade = initObjectCascade(path);
-	} catch (...) {
-		blog(LOG_WARNING, "failed to load model data \"%s\"",
-		     path.c_str());
-		return false;
-	}
-	return !_objectCascade.empty();
-}
-
-// Assumption is that QImage uses Format_RGBX8888.
+// Assumption is that QImage uses Format_RGBA8888.
 // Conversion from: https://github.com/dbzhang800/QtOpenCV
 cv::Mat QImageToMat(const QImage &img)
 {
@@ -211,34 +197,109 @@ QImage MatToQImage(const cv::Mat &mat)
 		return QImage();
 	}
 	return QImage(mat.data, mat.cols, mat.rows, mat.step,
-		      QImage::Format::Format_RGBX8888);
+		      QImage::Format::Format_RGBA8888);
 }
 
-void matchPattern(QImage &img, QImage &pattern, double threshold,
-		  cv::Mat &result)
+PatternMatchData createPatternData(QImage &pattern)
 {
-	if (img.isNull() || pattern.isNull()) {
+	PatternMatchData data;
+	if (pattern.isNull()) {
+		return data;
+	}
+
+	data.rgbaPattern = QImageToMat(pattern);
+	std::vector<cv::Mat1b> rgbaChannelsPattern;
+	cv::split(data.rgbaPattern, rgbaChannelsPattern);
+	std::vector<cv::Mat1b> rgbChanlesPattern(
+		rgbaChannelsPattern.begin(), rgbaChannelsPattern.begin() + 3);
+	cv::merge(rgbChanlesPattern, data.rgbPattern);
+	cv::threshold(rgbaChannelsPattern[3], data.mask, 0, 255,
+		      cv::THRESH_BINARY);
+	return data;
+}
+
+bool MacroConditionVideo::LoadImageFromFile()
+{
+	if (!_matchImage.load(QString::fromStdString(_file))) {
+		blog(LOG_WARNING, "Cannot load image data from file '%s'",
+		     _file.c_str());
+		return false;
+	}
+
+	_matchImage =
+		_matchImage.convertToFormat(QImage::Format::Format_RGBA8888);
+	_patternData = createPatternData(_matchImage);
+	return true;
+}
+
+bool MacroConditionVideo::LoadModelData(std::string &path)
+{
+	_modelDataPath = path;
+	_objectCascade = initObjectCascade(path);
+	return !_objectCascade.empty();
+}
+
+void matchPattern(QImage &img, PatternMatchData &patternData, double threshold,
+		  cv::Mat &result, bool useAlphaAsMask = true)
+{
+	if (img.isNull() || patternData.rgbaPattern.empty()) {
 		return;
 	}
-	if (img.height() < pattern.height() || img.width() < pattern.width()) {
+	if (img.height() < patternData.rgbaPattern.rows ||
+	    img.width() < patternData.rgbaPattern.cols) {
 		return;
 	}
 
 	auto i = QImageToMat(img);
-	auto p = QImageToMat(pattern);
 
-	cv::matchTemplate(i, p, result, cv::TM_CCOEFF_NORMED);
-	cv::threshold(result, result, threshold, 0, cv::THRESH_TOZERO);
+	if (useAlphaAsMask) {
+		std::vector<cv::Mat1b> rgbaChannelsImage;
+		cv::split(i, rgbaChannelsImage);
+		std::vector<cv::Mat1b> rgbChanlesImage(
+			rgbaChannelsImage.begin(),
+			rgbaChannelsImage.begin() + 3);
+
+		cv::Mat3b rgbImage;
+		cv::merge(rgbChanlesImage, rgbImage);
+
+		cv::matchTemplate(rgbImage, patternData.rgbPattern, result,
+				  cv::TM_CCORR_NORMED, patternData.mask);
+		cv::threshold(result, result, threshold, 0, cv::THRESH_TOZERO);
+
+	} else {
+		cv::matchTemplate(i, patternData.rgbaPattern, result,
+				  cv::TM_CCOEFF_NORMED);
+		cv::threshold(result, result, threshold, 0, cv::THRESH_TOZERO);
+	}
+}
+
+void matchPattern(QImage &img, QImage &pattern, double threshold,
+		  cv::Mat &result, bool useAlphaAsMask)
+{
+	auto data = createPatternData(pattern);
+	matchPattern(img, data, threshold, result, useAlphaAsMask);
 }
 
 bool MacroConditionVideo::ScreenshotContainsPattern()
 {
 	cv::Mat result;
-	matchPattern(_screenshotData->image, _matchImage, _patternThreshold,
-		     result);
+	matchPattern(_screenshotData->image, _patternData, _patternThreshold,
+		     result, _useAlphaAsMask);
 	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)
@@ -274,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:
@@ -353,12 +414,18 @@ 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(
 			"AdvSceneSwitcher.condition.video.patternThreshold"),
 		obs_module_text(
 			"AdvSceneSwitcher.condition.video.patternThresholdDescription"));
+	_useAlphaAsMask = new QCheckBox(obs_module_text(
+		"AdvSceneSwitcher.condition.video.patternThresholdUseAlphaAsMask"));
 
 	_modelDataPath = new FileSelection();
 	_objectScaleThreshold = new ThresholdSlider(
@@ -370,6 +437,8 @@ MacroConditionVideoEdit::MacroConditionVideoEdit(
 	_minNeighbors = new QSpinBox();
 	_minNeighbors->setMinimum(minMinNeighbors);
 	_minNeighbors->setMaximum(maxMinNeighbors);
+	_minNeighborsDescription = new QLabel(obs_module_text(
+		"AdvSceneSwitcher.condition.video.minNeighborDescription"));
 	_minSizeX = new QSpinBox();
 	_minSizeY = new QSpinBox();
 	_minSizeX->setMaximum(1024);
@@ -396,8 +465,12 @@ 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,
+			 SLOT(UseAlphaAsMaskChanged(int)));
 	QWidget::connect(_objectScaleThreshold,
 			 SIGNAL(DoubleValueChanged(double)), this,
 			 SLOT(ObjectScaleThresholdChanged(double)));
@@ -472,10 +545,13 @@ MacroConditionVideoEdit::MacroConditionVideoEdit(
 	showMatchLayout->addStretch();
 	QVBoxLayout *mainLayout = new QVBoxLayout;
 	mainLayout->addLayout(entryLine1Layout);
+	mainLayout->addWidget(_usePatternForChangedCheck);
 	mainLayout->addWidget(_patternThreshold);
+	mainLayout->addWidget(_useAlphaAsMask);
 	mainLayout->addLayout(_modelPathLayout);
 	mainLayout->addWidget(_objectScaleThreshold);
 	mainLayout->addLayout(_neighborsControlLayout);
+	mainLayout->addWidget(_minNeighborsDescription);
 	mainLayout->addLayout(_minSizeControlLayout);
 	mainLayout->addLayout(_maxSizeControlLayout);
 	mainLayout->addLayout(showMatchLayout);
@@ -526,11 +602,6 @@ void MacroConditionVideoEdit::SourceChanged(const QString &text)
 		QString::fromStdString(_entryData->GetShortDesc()));
 }
 
-bool needsPatternThreshold(VideoCondition cond)
-{
-	return cond == VideoCondition::PATTERN;
-}
-
 void MacroConditionVideoEdit::ConditionChanged(int cond)
 {
 	if (_loading || !_entryData) {
@@ -635,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) {
@@ -645,6 +728,17 @@ void MacroConditionVideoEdit::PatternThresholdChanged(double value)
 	_entryData->_patternThreshold = value;
 }
 
+void MacroConditionVideoEdit::UseAlphaAsMaskChanged(int value)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_useAlphaAsMask = value;
+	_entryData->LoadImageFromFile();
+}
+
 void MacroConditionVideoEdit::ObjectScaleThresholdChanged(double value)
 {
 	if (_loading || !_entryData) {
@@ -735,7 +829,7 @@ QImage markPatterns(cv::Mat &matchResult, QImage &image, QImage &pattern)
 				rectangle(matchImg, {col, row},
 					  cv::Point(col + pattern.width(),
 						    row + pattern.height()),
-					  cv::Scalar(255, 0, 0, 0), 2, 8, 0);
+					  cv::Scalar(255, 0, 0, 255), 2, 8, 0);
 			}
 		}
 	}
@@ -749,7 +843,7 @@ QImage markObjects(QImage &image, std::vector<cv::Rect> &objects)
 		rectangle(frame, cv::Point(objects[i].x, objects[i].y),
 			  cv::Point(objects[i].x + objects[i].width,
 				    objects[i].y + objects[i].height),
-			  cv::Scalar(255, 0, 0, 0), 2, 8, 0);
+			  cv::Scalar(255, 0, 0, 255), 2, 8, 0);
 	}
 	return MatToQImage(frame);
 }
@@ -769,11 +863,12 @@ 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->_patternThreshold, result,
+			     _entryData->_useAlphaAsMask);
 		if (countNonZero(result) == 0) {
 			DisplayMessage(obs_module_text(
 				"AdvSceneSwitcher.condition.video.patternMatchFail"));
@@ -810,9 +905,13 @@ void MacroConditionVideoEdit::ModelPathChanged(const QString &text)
 		return;
 	}
 
-	std::lock_guard<std::mutex> lock(switcher->m);
-	std::string path = text.toStdString();
-	if (!_entryData->LoadModelData(path)) {
+	bool dataLoaded = false;
+	{
+		std::lock_guard<std::mutex> lock(switcher->m);
+		std::string path = text.toStdString();
+		dataLoaded = _entryData->LoadModelData(path);
+	}
+	if (!dataLoaded) {
 		DisplayMessage(obs_module_text(
 			"AdvSceneSwitcher.condition.video.modelLoadFail"));
 	}
@@ -835,6 +934,19 @@ bool needsThrottleControls(VideoCondition cond)
 	       cond == VideoCondition::OBJECT;
 }
 
+bool needsThreshold(VideoCondition cond)
+{
+	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 setLayoutVisible(QLayout *layout, bool visible)
 {
 	for (int i = 0; i < layout->count(); ++i) {
@@ -848,13 +960,18 @@ void setLayoutVisible(QLayout *layout, bool visible)
 void MacroConditionVideoEdit::SetWidgetVisibility()
 {
 	_imagePath->setVisible(requiresFileInput(_entryData->_condition));
-	_patternThreshold->setVisible(
-		needsPatternThreshold(_entryData->_condition));
+	_usePatternForChangedCheck->setVisible(
+		patternControlIsOptional(_entryData->_condition));
+	_patternThreshold->setVisible(needsThreshold(_entryData->_condition));
+	_useAlphaAsMask->setVisible(_entryData->_condition ==
+				    VideoCondition::PATTERN);
 	_showMatch->setVisible(needsShowMatch(_entryData->_condition));
 	_objectScaleThreshold->setVisible(
 		needsObjectControls(_entryData->_condition));
 	setLayoutVisible(_neighborsControlLayout,
 			 needsObjectControls(_entryData->_condition));
+	_minNeighborsDescription->setVisible(
+		needsObjectControls(_entryData->_condition));
 	setLayoutVisible(_minSizeControlLayout,
 			 needsObjectControls(_entryData->_condition));
 	setLayoutVisible(_maxSizeControlLayout,
@@ -863,6 +980,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();
 }
 
@@ -876,7 +1000,10 @@ 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());
 	_objectScaleThreshold->SetDoubleValue(_entryData->_scaleFactor);
 	_minNeighbors->setValue(_entryData->_minNeighbors);

src/macro-segment.cpp

@@ -145,3 +145,8 @@ void MacroSegmentEdit::SetFocusPolicyOfWidgets()
 		w->installEventFilter(new MouseWheelWidgetAdjustmentGuard(w));
 	}
 }
+
+void MacroSegmentEdit::SetCollapsed(bool collapsed)
+{
+	_section->SetCollapsed(collapsed);
+}

src/macro-tab.cpp

@@ -170,42 +170,46 @@ void AdvSceneSwitcher::on_macroName_editingFinished()
 	emit MacroRenamed(oldName, newName);
 }
 
+void AdvSceneSwitcher::PopulateMacroActions(Macro &m, int afterIdx)
+{
+	bool root = afterIdx == 0;
+	auto &actions = m.Actions();
+	for (; afterIdx < actions.size(); afterIdx++) {
+		auto newEntry = new MacroActionEdit(this, &actions[afterIdx],
+						    actions[afterIdx]->GetId());
+		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)
+{
+	bool root = afterIdx == 0;
+	auto &conditions = m.Conditions();
+	for (; afterIdx < conditions.size(); afterIdx++) {
+		auto newEntry = new MacroConditionEdit(
+			this, &conditions[afterIdx],
+			conditions[afterIdx]->GetId(), root);
+		ConnectControlSignals(newEntry);
+		ui->macroEditConditionLayout->addWidget(newEntry);
+		ui->macroEditConditionHelp->setVisible(false);
+		root = false;
+	}
+	ui->macroEditConditionHelp->setVisible(conditions.size() == 0);
+}
+
 void AdvSceneSwitcher::SetEditMacro(Macro &m)
 {
 	ui->macroName->setText(m.Name().c_str());
 	clearLayout(ui->macroEditConditionLayout);
 	clearLayout(ui->macroEditActionLayout);
 
-	bool root = true;
-	for (auto &c : m.Conditions()) {
-		auto newEntry =
-			new MacroConditionEdit(this, &c, c->GetId(), root);
-		ConnectControlSignals(newEntry);
-		ui->macroEditConditionLayout->addWidget(newEntry);
-		ui->macroEditConditionHelp->setVisible(false);
-		root = false;
-	}
-
-	for (auto &a : m.Actions()) {
-		auto newEntry = new MacroActionEdit(this, &a, a->GetId());
-		ConnectControlSignals(newEntry);
-		ui->macroEditActionLayout->addWidget(newEntry);
-		ui->macroEditActionHelp->setVisible(false);
-	}
-
+	PopulateMacroConditions(m);
+	PopulateMacroActions(m);
 	ui->macroEdit->setDisabled(false);
-
-	if (m.Conditions().size() == 0) {
-		ui->macroEditConditionHelp->setVisible(true);
-	} else {
-		ui->macroEditConditionHelp->setVisible(false);
-	}
-
-	if (m.Actions().size() == 0) {
-		ui->macroEditActionHelp->setVisible(true);
-	} else {
-		ui->macroEditActionHelp->setVisible(false);
-	}
 }
 
 void AdvSceneSwitcher::HighlightAction(int idx)
@@ -400,17 +404,25 @@ void AdvSceneSwitcher::CopyMacro()
 	ui->macros->setCurrentItem(item);
 }
 
+void setCollapsedStateOfSegmentsIn(QLayout *layout, bool collapse)
+{
+	QLayoutItem *item = nullptr;
+	for (int i = 0; i < layout->count(); i++) {
+		item = layout->itemAt(i);
+		auto segment = dynamic_cast<MacroSegmentEdit *>(item->widget());
+		if (segment) {
+			segment->SetCollapsed(collapse);
+		}
+	}
+}
+
 void AdvSceneSwitcher::ExpandAllActions()
 {
 	auto m = getSelectedMacro();
 	if (!m) {
 		return;
 	}
-
-	for (auto &a : m->Actions()) {
-		a->SetCollapsed(false);
-	}
-	SetEditMacro(*m);
+	setCollapsedStateOfSegmentsIn(ui->macroEditActionLayout, false);
 }
 
 void AdvSceneSwitcher::ExpandAllConditions()
@@ -419,11 +431,7 @@ void AdvSceneSwitcher::ExpandAllConditions()
 	if (!m) {
 		return;
 	}
-
-	for (auto &c : m->Conditions()) {
-		c->SetCollapsed(false);
-	}
-	SetEditMacro(*m);
+	setCollapsedStateOfSegmentsIn(ui->macroEditConditionLayout, false);
 }
 
 void AdvSceneSwitcher::CollapseAllActions()
@@ -432,11 +440,7 @@ void AdvSceneSwitcher::CollapseAllActions()
 	if (!m) {
 		return;
 	}
-
-	for (auto &a : m->Actions()) {
-		a->SetCollapsed(true);
-	}
-	SetEditMacro(*m);
+	setCollapsedStateOfSegmentsIn(ui->macroEditActionLayout, true);
 }
 
 void AdvSceneSwitcher::CollapseAllConditions()
@@ -445,9 +449,5 @@ void AdvSceneSwitcher::CollapseAllConditions()
 	if (!m) {
 		return;
 	}
-
-	for (auto &c : m->Conditions()) {
-		c->SetCollapsed(true);
-	}
-	SetEditMacro(*m);
+	setCollapsedStateOfSegmentsIn(ui->macroEditConditionLayout, true);
 }

src/macro.cpp

@@ -113,7 +113,7 @@ bool Macro::PerformAction()
 			return false;
 		}
 	}
-	if (ret && _count != std::numeric_limits<int>::max()) {
+	if (_count != std::numeric_limits<int>::max()) {
 		_count++;
 	}
 	return ret;
@@ -492,7 +492,7 @@ bool SwitcherData::checkMacros()
 
 bool SwitcherData::runMacros()
 {
-	for (auto &m : macros) {
+	for (auto m : macros) {
 		if (m.Matched()) {
 			vblog(LOG_INFO, "running macro: %s", m.Name().c_str());
 			if (!m.PerformAction()) {

src/scene-trigger.cpp

@@ -156,7 +156,7 @@ void SceneTrigger::logMatch()
 	blog(LOG_INFO,
 	     "scene '%s' in status '%s' triggering action '%s' after %f seconds",
 	     GetWeakSourceName(scene).c_str(), statusName.c_str(),
-	     actionName.c_str(), duration);
+	     actionName.c_str(), duration.seconds);
 }
 
 void frontEndActionThread(sceneTriggerAction action, double delay)
@@ -265,13 +265,15 @@ void SceneTrigger::performAction()
 	std::thread t;
 
 	if (isFrontendAction(triggerAction)) {
-		t = std::thread(frontEndActionThread, triggerAction, duration);
+		t = std::thread(frontEndActionThread, triggerAction,
+				duration.seconds);
 	} else if (isAudioAction(triggerAction)) {
 		bool mute = triggerAction == sceneTriggerAction::MUTE_SOURCE;
-		t = std::thread(muteThread, audioSource, duration, mute);
+		t = std::thread(muteThread, audioSource, duration.seconds,
+				mute);
 	} else if (isSwitcherStatusAction(triggerAction)) {
 		bool stop = triggerAction == sceneTriggerAction::STOP_SWITCHER;
-		t = std::thread(statusThread, duration, stop);
+		t = std::thread(statusThread, duration.seconds, stop);
 	} else {
 		blog(LOG_WARNING, "ignoring unknown action '%d'",
 		     static_cast<int>(triggerAction));
@@ -374,7 +376,7 @@ void SceneTrigger::save(obs_data_t *obj)
 	obs_data_set_string(obj, "scene", GetWeakSourceName(scene).c_str());
 	obs_data_set_int(obj, "triggerType", static_cast<int>(triggerType));
 	obs_data_set_int(obj, "triggerAction", static_cast<int>(triggerAction));
-	obs_data_set_double(obj, "duration", duration);
+	duration.Save(obj, "duration");
 	obs_data_set_string(obj, "audioSource",
 			    GetWeakSourceName(audioSource).c_str());
 }
@@ -388,7 +390,7 @@ void SceneTrigger::load(obs_data_t *obj)
 		obs_data_get_int(obj, "triggerType"));
 	triggerAction = static_cast<sceneTriggerAction>(
 		obs_data_get_int(obj, "triggerAction"));
-	duration = obs_data_get_double(obj, "duration");
+	duration.Load(obj, "duration");
 
 	const char *audioSourceName = obs_data_get_string(obj, "audioSource");
 	audioSource = GetWeakSourceByName(audioSourceName);
@@ -451,19 +453,17 @@ SceneTriggerWidget::SceneTriggerWidget(QWidget *parent, SceneTrigger *s)
 {
 	triggers = new QComboBox();
 	actions = new QComboBox();
-	duration = new QDoubleSpinBox();
+	duration = new DurationSelection();
 	audioSources = new QComboBox();
 
-	duration->setMinimum(0.0);
-	duration->setMaximum(99.000000);
-	duration->setSuffix("s");
-
 	QWidget::connect(triggers, SIGNAL(currentIndexChanged(int)), this,
 			 SLOT(TriggerTypeChanged(int)));
 	QWidget::connect(actions, SIGNAL(currentIndexChanged(int)), this,
 			 SLOT(TriggerActionChanged(int)));
-	QWidget::connect(duration, SIGNAL(valueChanged(double)), this,
+	QWidget::connect(duration, SIGNAL(DurationChanged(double)), this,
 			 SLOT(DurationChanged(double)));
+	QWidget::connect(duration, SIGNAL(UnitChanged(DurationUnit)), this,
+			 SLOT(DurationUnitChanged(DurationUnit)));
 	QWidget::connect(audioSources,
 			 SIGNAL(currentTextChanged(const QString &)), this,
 			 SLOT(AudioSourceChanged(const QString &)));
@@ -475,7 +475,7 @@ SceneTriggerWidget::SceneTriggerWidget(QWidget *parent, SceneTrigger *s)
 	if (s) {
 		triggers->setCurrentIndex(static_cast<int>(s->triggerType));
 		actions->setCurrentIndex(static_cast<int>(s->triggerAction));
-		duration->setValue(s->duration);
+		duration->SetDuration(s->duration);
 
 		audioSources->setCurrentText(
 			GetWeakSourceName(s->audioSource).c_str());
@@ -552,14 +552,24 @@ void SceneTriggerWidget::TriggerActionChanged(int index)
 	}
 }
 
-void SceneTriggerWidget::DurationChanged(double dur)
+void SceneTriggerWidget::DurationChanged(double seconds)
 {
 	if (loading || !switchData) {
 		return;
 	}
 
 	std::lock_guard<std::mutex> lock(switcher->m);
-	switchData->duration = dur;
+	switchData->duration.seconds = seconds;
+}
+
+void SceneTriggerWidget::DurationUnitChanged(DurationUnit unit)
+{
+	if (loading || !switchData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	switchData->duration.displayUnit = unit;
 }
 
 void SceneTriggerWidget::AudioSourceChanged(const QString &text)

src/screenshot-helper.cpp

@@ -79,7 +79,7 @@ void AdvSSScreenshotObj::Copy()
 	uint8_t *videoData = nullptr;
 	uint32_t videoLinesize = 0;
 
-	image = QImage(cx, cy, QImage::Format::Format_RGBX8888);
+	image = QImage(cx, cy, QImage::Format::Format_RGBA8888);
 
 	if (gs_stagesurface_map(stagesurf, &videoData, &videoLinesize)) {
 		int linesize = image.bytesPerLine();

src/section.cpp

@@ -93,6 +93,11 @@ void Section::AddHeaderWidget(QWidget *w)
 	_headerWidgetLayout->addWidget(w);
 }
 
+void Section::SetCollapsed(bool collapsed)
+{
+	Collapse(collapsed);
+}
+
 bool Section::eventFilter(QObject *obj, QEvent *event)
 {
 	if (event->type() == QEvent::Resize && !_transitioning && !_collapsed) {

src/switch-sequence.cpp

@@ -392,6 +392,11 @@ SceneSequenceSwitch *SceneSequenceSwitch::extend()
 	}
 	extendedSequence = std::make_unique<SceneSequenceSwitch>();
 	extendedSequence->startScene = scene;
+	if (targetType == SwitchTargetType::SceneGroup) {
+		extendedSequence->startScene = nullptr;
+		extendedSequence->startTargetType =
+			SwitchTargetType::SceneGroup;
+	}
 	return extendedSequence.get();
 }
 

src/switch-video.cpp

@@ -266,7 +266,7 @@ bool VideoSwitch::loadImageFromFile()
 		return false;
 	}
 	matchImage =
-		matchImage.convertToFormat(QImage::Format::Format_RGBX8888);
+		matchImage.convertToFormat(QImage::Format::Format_RGBA8888);
 	return true;
 }
 

src/utility.cpp

@@ -12,6 +12,7 @@
 #include <QTimer>
 #include <QMessageBox>
 #include <QJsonDocument>
+#include <QSystemTrayIcon>
 #include <unordered_map>
 #include <regex>
 #include <set>
@@ -213,10 +214,10 @@ void deleteLayoutItem(QLayoutItem *item)
 	}
 }
 
-void clearLayout(QLayout *layout)
+void clearLayout(QLayout *layout, int afterIdx)
 {
 	QLayoutItem *item;
-	while ((item = layout->takeAt(0))) {
+	while (item = layout->takeAt(afterIdx)) {
 		if (item->layout()) {
 			clearLayout(item->layout());
 			delete item->layout();
@@ -443,6 +444,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)
 {