Cleanup

* Use OBSSourceAutoRelease * Do not return true if source selection is invalid
Fix crash when asking for settings backup
2026-08-29 12:45:28 -05:00 · 2023-12-17 10:40:29 +01:00 · 2023-12-16 19:02:38 +01:00 · 2023-12-13 19:29:14 +01:00 · 2023-12-13 14:19:17 +01:00 · 2023-12-10 14:26:30 +01:00
71 changed files with 1860 additions and 653 deletions
--- a/.github/scripts/.Aptfile
+++ b/.github/scripts/.Aptfile
@@ -7,3 +7,8 @@ package 'ninja-build', bin: 'ninja'
 package 'pkg-config'
 package 'clang'
 package 'clang-format-13'
+package 'libxtst-dev'
+package 'libxss-dev'
+package 'libopencv-dev'
+package 'libtesseract-dev'
+package 'libprocps-dev'
--- a/.github/scripts/utils.zsh/setup_linux
+++ b/.github/scripts/utils.zsh/setup_linux
@@ -34,13 +34,6 @@ if (( ! (${skips[(Ie)all]} + ${skips[(Ie)deps]}) )) {

  log_info 'Installing obs plugin dependencies...'

-  sudo apt-get install -y \
-    libxtst-dev \
-    libxss-dev \
-    libopencv-dev \
-    libtesseract-dev \
-    libprocps-dev
-
  local -a _qt_packages=()

  if (( QT_VERSION == 5 )) {
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -93,6 +93,8 @@ target_sources(
  ${LIB_NAME}
  PRIVATE src/macro-core/macro-action-audio.cpp
          src/macro-core/macro-action-audio.hpp
+          src/macro-core/macro-action-clipboard.cpp
+          src/macro-core/macro-action-clipboard.hpp
          src/macro-core/macro-action-edit.cpp
          src/macro-core/macro-action-edit.hpp
          src/macro-core/macro-action-file.cpp
@@ -254,6 +256,8 @@ target_sources(
          src/utils/connection-manager.hpp
          src/utils/curl-helper.cpp
          src/utils/curl-helper.hpp
+          src/utils/duration.cpp
+          src/utils/duration.hpp
          src/utils/duration-control.cpp
          src/utils/duration-control.hpp
          src/utils/export-symbol-helper.hpp
@@ -287,6 +291,8 @@ target_sources(
          src/utils/obs-module-helper.hpp
          src/utils/osc-helpers.cpp
          src/utils/osc-helpers.hpp
+          src/utils/plugin-state-helper.cpp
+          src/utils/plugin-state-helper.hpp
          src/utils/priority-helper.cpp
          src/utils/priority-helper.hpp
          src/utils/process-config.cpp
@@ -458,27 +464,24 @@ else()

  find_path(PROCPS_INCLUDE_DIR NAMES proc/procps.h)
  find_path(PROCPS2_INCLUDE_DIR NAMES libproc2/pids.h)
-  find_library(PROCPS_LIBRARY NAMES procps)
-  find_library(PROCPS2_LIBRARY NAMES proc2)
-  if(PROCPS_INCLUDE_DIR AND PROCPS_LIBRARY)
+  if(PROCPS_INCLUDE_DIR)
    message(STATUS "${PROJECT_NAME} using procps")
    set(PROC_INCLUDE_DIR "${PROCPS_INCLUDE_DIR}")
-    set(PROC_LIBRARY "${PROCPS_LIBRARY}")
-    target_compile_definitions(${LIB_NAME} PRIVATE USE_PROCPS)
-  elseif(PROCPS2_INCLUDE_DIR AND PROCPS2_LIBRARY)
+    target_compile_definitions(${LIB_NAME} PRIVATE PROCPS_AVAILABLE)
+    set(PROCESS_CONDITION_SUPPORTED 1)
+  endif()
+  if(PROCPS2_INCLUDE_DIR)
    message(STATUS "${PROJECT_NAME} using libproc2")
    set(PROC_INCLUDE_DIR "${PROCPS2_INCLUDE_DIR}")
-    set(PROC_LIBRARY "${PROCPS2_LIBRARY}")
-  else()
-    message(
-      FATAL_ERROR
-        "found neither procps nor libproc2!
-      please either set ...
-      PROCPS_INCLUDE_DIR and PROCPS_LIBRARY
-      ... or ...
-      PROCPS2_INCLUDE_DIR and PROCPS2_LIBRARY")
+    target_compile_definitions(${LIB_NAME} PRIVATE PROCPS2_AVAILABLE)
+    set(PROCESS_CONDITION_SUPPORTED 1)
+  endif()
+  if(NOT DEFINED PROCESS_CONDITION_SUPPORTED)
+    message(
+      WARNING
+        "found neither procps nor libproc2! Process condition will not be functional!"
+    )
  endif()
-  target_link_libraries(${LIB_NAME} PRIVATE "${PROC_LIBRARY}")
  target_include_directories(${LIB_NAME} PRIVATE "${PROC_INCLUDE_DIR}")

  find_package(CURL)
--- a/data/locale/de-DE.ini
+++ b/data/locale/de-DE.ini
@@ -221,9 +221,8 @@ AdvSceneSwitcher.condition.record="Aufnahme"
 AdvSceneSwitcher.condition.record.state.start="Aufnahme läuft"
 AdvSceneSwitcher.condition.record.state.pause="Aufnahme pausiert"
 AdvSceneSwitcher.condition.record.state.stop="Aufnahme gestoppt"
-AdvSceneSwitcher.condition.record.entry="{{recordState}}"
 AdvSceneSwitcher.condition.process="Prozess"
-AdvSceneSwitcher.condition.process.entry="{{processes}} läuft {{focused}} und ist fokusiert"
+AdvSceneSwitcher.condition.process.entry="{{processes}}{{regex}}läuft{{focused}}und ist fokusiert"
 AdvSceneSwitcher.condition.process.entry.focus="Aktueller Vordergrundprozess: {{focusProcess}}"
 AdvSceneSwitcher.condition.idle="Leerlauf"
 AdvSceneSwitcher.condition.idle.entry="Keine Tastatur- oder Mauseingaben für {{duration}}"
--- a/data/locale/en-US.ini
+++ b/data/locale/en-US.ini
@@ -79,6 +79,7 @@ AdvSceneSwitcher.macroTab.edit.action="Action type:"
 AdvSceneSwitcher.macroTab.add="Add new macro"
 AdvSceneSwitcher.macroTab.name="Name:"
 AdvSceneSwitcher.macroTab.run="Run macro"
+AdvSceneSwitcher.macroTab.run.tooltip="Run all macro actions regardless of condition.\nIf else actions are available, hold Shift and click the button to execute them instead."
 AdvSceneSwitcher.macroTab.runElse="Run macro (else)"
 AdvSceneSwitcher.macroTab.runFail="Running \"%1\" failed!\nEither one of the actions failed or the macro is running already."
 AdvSceneSwitcher.macroTab.runInParallel="Run macro in parallel to other macros"
@@ -125,6 +126,8 @@ AdvSceneSwitcher.macroTab.currentDockButtonText.unpause="Unpause button text:"
 AdvSceneSwitcher.macroTab.currentDockStatusText.true="Conditions true text:"
 AdvSceneSwitcher.macroTab.currentDockStatusText.false="Conditions false text:"
 AdvSceneSwitcher.macroTab.currentDockHighlightIfExecuted="Highlight dock if macro actions were recently executed"
+AdvSceneSwitcher.macroTab.toggleElseActions.hide.tooltip="Hide else actions"
+AdvSceneSwitcher.macroTab.toggleElseActions.show.tooltip="Show else actions"

 AdvSceneSwitcher.macroDock.pause="Pause"
 AdvSceneSwitcher.macroDock.unpause="Unpause"
@@ -295,9 +298,10 @@ AdvSceneSwitcher.condition.record="Recording"
 AdvSceneSwitcher.condition.record.state.start="Recording running"
 AdvSceneSwitcher.condition.record.state.pause="Recording paused"
 AdvSceneSwitcher.condition.record.state.stop="Recording stopped"
-AdvSceneSwitcher.condition.record.entry="{{recordState}}"
+AdvSceneSwitcher.condition.record.state.duration="Recording duration is longer than"
+AdvSceneSwitcher.condition.record.entry="{{condition}}{{duration}}"
 AdvSceneSwitcher.condition.process="Process"
-AdvSceneSwitcher.condition.process.entry="{{processes}}is running{{focused}}and is focused"
+AdvSceneSwitcher.condition.process.entry="{{processes}}{{regex}}is running{{focused}}and is focused"
 AdvSceneSwitcher.condition.process.entry.focus="Current foreground process:{{focusProcess}}"
 AdvSceneSwitcher.condition.idle="Idle"
 AdvSceneSwitcher.condition.idle.entry="No keyboard or mouse inputs for{{duration}}"
@@ -326,6 +330,7 @@ AdvSceneSwitcher.condition.macro.type.state="Macro condition state"
 AdvSceneSwitcher.condition.macro.type.multiState="Multiple macro condition state"
 AdvSceneSwitcher.condition.macro.type.actionDisabled="Macro action disabled"
 AdvSceneSwitcher.condition.macro.type.actionEnabled="Macro action enabled"
+AdvSceneSwitcher.condition.macro.type.paused="Macro is paused"
 AdvSceneSwitcher.condition.macro.type.selection="{{types}}"
 AdvSceneSwitcher.condition.macro.count.type.below="Less than"
 AdvSceneSwitcher.condition.macro.count.type.above="More than"
@@ -341,6 +346,7 @@ AdvSceneSwitcher.condition.macro.count.entry.line1="{{macros}}was executed{{cond
 AdvSceneSwitcher.condition.macro.count.entry.line2="Current count:{{currentCount}}{{resetCount}}"
 AdvSceneSwitcher.condition.macro.actionState.disabled.entry="Action{{actionIndex}}of{{macros}}is disabled"
 AdvSceneSwitcher.condition.macro.actionState.enabled.entry="Action{{actionIndex}}of{{macros}}is enabled"
+AdvSceneSwitcher.condition.macro.paused.entry="Macro{{macros}}is paused"
 AdvSceneSwitcher.condition.source="Source"
 AdvSceneSwitcher.condition.source.type.active="Is active"
 AdvSceneSwitcher.condition.source.type.showing="Is showing"
@@ -874,6 +880,12 @@ AdvSceneSwitcher.action.twitch.announcement.blue="Blue"
 AdvSceneSwitcher.action.twitch.announcement.green="Green"
 AdvSceneSwitcher.action.twitch.announcement.orange="Orange"
 AdvSceneSwitcher.action.twitch.announcement.purple="Purple"
+AdvSceneSwitcher.action.clipboard="Clipboard"
+AdvSceneSwitcher.action.clipboard.type.copy.text="Copy text"
+AdvSceneSwitcher.action.clipboard.type.copy.image="Copy image"
+AdvSceneSwitcher.action.clipboard.copy.text.text.placeholder="Enter text"
+AdvSceneSwitcher.action.clipboard.copy.image.url.placeholder="Enter direct image URL"
+AdvSceneSwitcher.action.clipboard.copy.image.url.tooltip="Currently supported formats: PNG, JPG/JPEG, BMP, GIF."

 ; Hotkey
 AdvSceneSwitcher.hotkey.startSwitcherHotkey="Start the Advanced Scene Switcher"
@@ -1442,6 +1454,11 @@ AdvSceneSwitcher.tempVar.audio.sync_offset="Source audio sync offset"
 AdvSceneSwitcher.tempVar.audio.monitor="Source audio monitor type"
 AdvSceneSwitcher.tempVar.audio.balance="Source audio balance"

+AdvSceneSwitcher.tempVar.clipboard.mimeType.primary="Primary clipboard item MIME type"
+AdvSceneSwitcher.tempVar.clipboard.mimeType.primary.description="Highest priority MIME type of the current item stored in clipboard, if available."
+AdvSceneSwitcher.tempVar.clipboard.mimeType.all="All clipboard item MIME types"
+AdvSceneSwitcher.tempVar.clipboard.mimeType.all.description="All MIME types of the current item stored in clipboard separated with space, if available."
+
 AdvSceneSwitcher.tempVar.scene.current="Current scene"
 AdvSceneSwitcher.tempVar.scene.previous="Previous scene"
 AdvSceneSwitcher.tempVar.scene.preview="Preview scene"
@@ -1468,6 +1485,27 @@ AdvSceneSwitcher.tempVar.midi.note="Note"
 AdvSceneSwitcher.tempVar.midi.value1="Value 1"
 AdvSceneSwitcher.tempVar.midi.value2="Value 2"

+AdvSceneSwitcher.tempVar.macro.runCount="Run count"
+AdvSceneSwitcher.tempVar.macro.runCount.description="The number of times a macro was executed."
+AdvSceneSwitcher.tempVar.macro.matchedCount="Matched count"
+AdvSceneSwitcher.tempVar.macro.matchedCount.description="The number of macros of which the condition state was true."
+
+AdvSceneSwitcher.tempVar.process.name="Process name"
+
+AdvSceneSwitcher.tempVar.recording.durationSeconds="Recording duration"
+AdvSceneSwitcher.tempVar.recording.durationSeconds.description="Recording duration in seconds.\nThis value does not change while the recording is paused and will be reset to zero if the recording is stopped."
+
+AdvSceneSwitcher.tempVar.video.patternCount="Pattern count"
+AdvSceneSwitcher.tempVar.video.patternCount.description="The number of times the given pattern has been found in a given video input frame."
+AdvSceneSwitcher.tempVar.video.objectCount="Object count"
+AdvSceneSwitcher.tempVar.video.objectCount.description="The number of objects the given model has identified in a given video input frame."
+AdvSceneSwitcher.tempVar.video.brightness="Average brightness"
+AdvSceneSwitcher.tempVar.video.brightness.description="The average brightness in a given video input frame in a range from 0 to 1 (dark to bright)."
+AdvSceneSwitcher.tempVar.video.text="OCR text"
+AdvSceneSwitcher.tempVar.video.text.description="The text detected in a given video input frame."
+AdvSceneSwitcher.tempVar.video.color="Average color"
+AdvSceneSwitcher.tempVar.video.color.description="The average RGB color in a given video input frame in HexArgb format."
+
 AdvSceneSwitcher.selectScene="--select scene--"
 AdvSceneSwitcher.selectPreviousScene="Previous Scene"
 AdvSceneSwitcher.selectCurrentScene="Current Scene"
--- a/data/locale/es-ES.ini
+++ b/data/locale/es-ES.ini
@@ -182,9 +182,8 @@ AdvSceneSwitcher.condition.record="Grabación"
 AdvSceneSwitcher.condition.record.state.start="Grabación en ejecución"
 AdvSceneSwitcher.condition.record.state.pause="Grabación en pausa"
 AdvSceneSwitcher.condition.record.state.stop="Grabación detenida"
-AdvSceneSwitcher.condition.record.entry="{{recordState}}"
 AdvSceneSwitcher.condition.process="Proceso"
-AdvSceneSwitcher.condition.process.entry="{{processes}} se está ejecutando {{focused}} y está enfocado"
+AdvSceneSwitcher.condition.process.entry="{{processes}}{{regex}}se está ejecutando{{focused}}y está enfocado"
 AdvSceneSwitcher.condition.idle="Inactivo"
 AdvSceneSwitcher.condition.idle.entry="No hay entradas de teclado o ratón durante {{duration}}"
 AdvSceneSwitcher.condition.pluginState="Estado del complemento"
--- a/data/locale/fr-FR.ini
+++ b/data/locale/fr-FR.ini
@@ -286,7 +286,7 @@ AdvSceneSwitcher.condition.record.state.start="Enregistrement en cours"
 AdvSceneSwitcher.condition.record.state.pause="Enregistrement en pause"
 AdvSceneSwitcher.condition.record.state.stop="Arrêt de l'enregistrement"
 AdvSceneSwitcher.condition.process="Processus"
-AdvSceneSwitcher.condition.process.entry="{{processes}}en cours d'exécution{{focused}}et est au premier plan"
+AdvSceneSwitcher.condition.process.entry="{{processes}}{{regex}}en cours d'exécution{{focused}}et est au premier plan"
 AdvSceneSwitcher.condition.process.entry.focus="Processus au premier plan actuel :{{focusProcess}}"
 AdvSceneSwitcher.condition.idle="Inactif"
 AdvSceneSwitcher.condition.idle.entry="Aucune entrée de clavier ou de souris pendant{{duration}}"
--- a/data/locale/ru-RU.ini
+++ b/data/locale/ru-RU.ini
@@ -107,7 +107,7 @@ AdvSceneSwitcher.condition.record.state.start="Запись запущена"
 AdvSceneSwitcher.condition.record.state.pause="Запись приостановлена"
 AdvSceneSwitcher.condition.record.state.stop="Запись остановлена"
 AdvSceneSwitcher.condition.process="Процесс"
-AdvSceneSwitcher.condition.process.entry="{{processes}} запущен {{focused}} и сфокусирован"
+AdvSceneSwitcher.condition.process.entry="{{processes}}{{regex}}запущен{{focused}}и сфокусирован"
 AdvSceneSwitcher.condition.idle="Простой"
 AdvSceneSwitcher.condition.idle.entry="Не было ни клавиатуры, ни мыши в течении{{duration}}"
 AdvSceneSwitcher.condition.pluginState="Состояние плагина"
--- a/data/locale/tr-TR.ini
+++ b/data/locale/tr-TR.ini
@@ -159,9 +159,8 @@ AdvSceneSwitcher.condition.record="Kayıt"
 AdvSceneSwitcher.condition.record.state.start="Kayıt Çalışıyor"
 AdvSceneSwitcher.condition.record.state.pause="Kayıt durakladı"
 AdvSceneSwitcher.condition.record.state.stop="Kayıt durdu"
-AdvSceneSwitcher.condition.record.entry="{{recordState}}"
 AdvSceneSwitcher.condition.process="İşlem"
-AdvSceneSwitcher.condition.process.entry="{{processes}} çalışıyor {{focused}} ve odaklandı"
+AdvSceneSwitcher.condition.process.entry="{{processes}}{{regex}}çalışıyor{{focused}}ve odaklandı"
 AdvSceneSwitcher.condition.idle="Boşta"
 AdvSceneSwitcher.condition.idle.entry="...için klavye veya fare girişi yok {{duration}}"
 AdvSceneSwitcher.condition.pluginState="Eklenti durumu"
--- a/data/locale/zh-CN.ini
+++ b/data/locale/zh-CN.ini
@@ -267,9 +267,8 @@ AdvSceneSwitcher.condition.record="录制"
 AdvSceneSwitcher.condition.record.state.start="录制运行中"
 AdvSceneSwitcher.condition.record.state.pause="录制暂停"
 AdvSceneSwitcher.condition.record.state.stop="录制停止"
-AdvSceneSwitcher.condition.record.entry="{{recordState}}"
 AdvSceneSwitcher.condition.process="进程"
-AdvSceneSwitcher.condition.process.entry="{{processes}} 是正在运行 {{focused}} 并且是获得焦点"
+AdvSceneSwitcher.condition.process.entry="{{processes}}{{regex}}是正在运行{{focused}}并且是获得焦点"
 AdvSceneSwitcher.condition.process.entry.focus="当前焦点进程: {{focusProcess}}"
 AdvSceneSwitcher.condition.idle="闲置检测"
 AdvSceneSwitcher.condition.idle.entry="没有键盘或鼠标输入{{duration}}"
--- a/data/res/images/DarkNotEqual.svg
+++ b/data/res/images/DarkNotEqual.svg
@@ -0,0 +1,11 @@
+<?xml version="1.0"?>
+<svg width="16" height="16" xmlns="http://www.w3.org/2000/svg" xmlns:svg="http://www.w3.org/2000/svg" preserveAspectRatio="xMidYMid meet" version="1.1">
+ <!-- Created with SVG-edit - https://github.com/SVG-Edit/svgedit-->
+
+ <g class="layer">
+  <title>Layer 1</title>
+  <rect fill="#fefefe" height="2.25" id="svg_1" stroke="#fefefe" stroke-dasharray="null" stroke-linecap="null" stroke-linejoin="null" transform="matrix(1, 0, 0, 1, 0, 0)" width="13" x="1.5" y="4"/>
+  <rect fill="#fefefe" height="2.25" id="svg_2" stroke="#fefefe" stroke-dasharray="null" stroke-linecap="null" stroke-linejoin="null" transform="matrix(1, 0, 0, 1, 0, 0)" width="13" x="1.5" y="10"/>
+  <rect fill="#fefefe" height="1" id="svg_4" stroke="#fefefe" stroke-dasharray="null" stroke-linecap="null" stroke-linejoin="null" transform="matrix(0.341951, -0.926734, 0.939718, 0.337226, -1.948, 13.2448)" width="14" x="1" y="7"/>
+ </g>
+</svg>
--- a/data/res/images/LightNotEqual.svg
+++ b/data/res/images/LightNotEqual.svg
@@ -0,0 +1,11 @@
+<?xml version="1.0"?>
+<svg width="16" height="16" xmlns="http://www.w3.org/2000/svg" xmlns:svg="http://www.w3.org/2000/svg" preserveAspectRatio="xMidYMid meet" version="1.1">
+ <!-- Created with SVG-edit - https://github.com/SVG-Edit/svgedit-->
+
+ <g class="layer">
+  <title>Layer 1</title>
+  <rect fill="#202020" height="2.25" id="svg_1" stroke="#202020" stroke-dasharray="null" stroke-linecap="null" stroke-linejoin="null" transform="matrix(1, 0, 0, 1, 0, 0)" width="13" x="1.5" y="4"/>
+  <rect fill="#202020" height="2.25" id="svg_2" stroke="#202020" stroke-dasharray="null" stroke-linecap="null" stroke-linejoin="null" transform="matrix(1, 0, 0, 1, 0, 0)" width="13" x="1.5" y="10"/>
+  <rect fill="#202020" height="1" id="svg_4" stroke="#202020" stroke-dasharray="null" stroke-linecap="null" stroke-linejoin="null" transform="matrix(0.341951, -0.926734, 0.939718, 0.337226, -1.948, 13.2448)" width="14" x="1" y="7"/>
+ </g>
+</svg>
--- a/forms/advanced-scene-switcher.ui
+++ b/forms/advanced-scene-switcher.ui
@@ -119,7 +119,7 @@
                       <string notr="true">ms</string>
                      </property>
                      <property name="minimum">
-                       <number>50</number>
+                       <number>10</number>
                      </property>
                      <property name="maximum">
                       <number>20000</number>
@@ -1275,6 +1275,22 @@
                    </property>
                   </spacer>
                  </item>
+                  <item>
+                   <widget class="QPushButton" name="toggleElseActions">
+                    <property name="maximumSize">
+                     <size>
+                      <width>22</width>
+                      <height>16777215</height>
+                     </size>
+                    </property>
+                    <property name="checkable">
+                     <bool>true</bool>
+                    </property>
+                    <property name="flat">
+                     <bool>true</bool>
+                    </property>
+                   </widget>
+                  </item>
                 </layout>
                </item>
               </layout>
--- a/src/advanced-scene-switcher.cpp
+++ b/src/advanced-scene-switcher.cpp
@@ -10,6 +10,7 @@
 #include <QMainWindow>
 #include <QAction>
 #include <QFileDialog>
+#include <QTextStream>
 #include <QDirIterator>
 #include <regex>
 #include <filesystem>
@@ -115,10 +116,27 @@ void AdvSceneSwitcher::LoadUI()
 	loading = false;
 }

+bool AdvSceneSwitcher::eventFilter(QObject *obj, QEvent *event)
+{
+	auto eventType = event->type();
+	if (obj == ui->macroElseActions && eventType == QEvent::Resize) {
+		QResizeEvent *resizeEvent = static_cast<QResizeEvent *>(event);
+
+		if (resizeEvent->size().height() == 0) {
+			SetElseActionsStateToHidden();
+			return QDialog::eventFilter(obj, event);
+		}
+
+		SetElseActionsStateToVisible();
+	}
+
+	return QDialog::eventFilter(obj, event);
+}
+
 /******************************************************************************
 * Saving and loading
 ******************************************************************************/
-static void AskForBackup(obs_data_t *obj);
+static void AskForBackup(const QString &json);

 static void SaveSceneSwitcher(obs_data_t *save_data, bool saving, void *)
 {
@@ -139,16 +157,25 @@ static void SaveSceneSwitcher(obs_data_t *save_data, bool saving, void *)
 		switcher->Stop();

 		switcher->m.lock();
-		obs_data_t *obj =
+		OBSDataAutoRelease obj =
 			obs_data_get_obj(save_data, "advanced-scene-switcher");
 		if (!obj) {
 			obj = obs_data_create();
 		}
 		if (switcher->VersionChanged(obj, g_GIT_SHA1)) {
-			AskForBackup(obj);
+			auto json = obs_data_get_json(obj);
+			static QString jsonQString = json ? json : "";
+			std::thread t([]() {
+				obs_queue_task(
+					OBS_TASK_UI,
+					[](void *) {
+						AskForBackup(jsonQString);
+					},
+					nullptr, false);
+			});
+			t.detach();
 		}
 		switcher->LoadSettings(obj);
-		obs_data_release(obj);
 		switcher->m.unlock();

 		if (!switcher->stop) {
@@ -157,12 +184,12 @@ static void SaveSceneSwitcher(obs_data_t *save_data, bool saving, void *)
 	}
 }

-static void AskForBackup(obs_data_t *obj)
+static void AskForBackup(const QString &json)
 {
-	bool backupSettings = DisplayMessage(
-		obs_module_text("AdvSceneSwitcher.askBackup"), true);
+	const bool backupWasConfirmed = DisplayMessage(
+		obs_module_text("AdvSceneSwitcher.askBackup"), true, false);

-	if (!backupSettings) {
+	if (!backupWasConfirmed) {
 		return;
 	}

@@ -181,8 +208,8 @@ static void AskForBackup(obs_data_t *obj)
 	if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
 		return;
 	}
-
-	obs_data_save_json(obj, file.fileName().toUtf8().constData());
+	auto out = QTextStream(&file);
+	out << json;
 }

 /******************************************************************************
@@ -330,12 +357,8 @@ void SwitcherData::SetPreconditions()
 	InvalidateMacroTempVarValues();
 }

-void ClearWebsocketMessages();
-
 void SwitcherData::ResetForNextInterval()
 {
-	// Core reset functions
-	ClearWebsocketMessages();
 	// Plugin reset functions
 	for (const auto &func : resetIntervalSteps) {
 		func();
@@ -759,6 +782,9 @@ void OpenSettingsWindow()
 	}
 }

+void SetupConnectionManager();
+void SetupWebsocketHelpers();
+
 extern "C" void InitSceneSwitcher(obs_module_t *module, translateFunc translate)
 {
 	blog(LOG_INFO, "version: %s", g_GIT_TAG);
@@ -769,6 +795,8 @@ extern "C" void InitSceneSwitcher(obs_module_t *module, translateFunc translate)
 	PlatformInit();
 	LoadPlugins();
 	SetupDock();
+	SetupConnectionManager();
+	SetupWebsocketHelpers();

 	obs_frontend_add_save_callback(SaveSceneSwitcher, nullptr);
 	obs_frontend_add_event_callback(OBSEvent, switcher);
--- a/src/advanced-scene-switcher.hpp
+++ b/src/advanced-scene-switcher.hpp
@@ -39,6 +39,9 @@ public:
 	void RestoreWindowGeo();
 	void CheckFirstTimeSetup();

+protected:
+	bool eventFilter(QObject *obj, QEvent *event) override;
+
 	/* --- Begin of general tab section --- */
 public:
 	void SetupGeneralTab();
@@ -115,6 +118,7 @@ public slots:
 	void on_actionUp_clicked();
 	void on_actionDown_clicked();
 	void on_actionBottom_clicked();
+	void on_toggleElseActions_clicked();
 	void on_elseActionAdd_clicked();
 	void on_elseActionRemove_clicked();
 	void on_elseActionTop_clicked();
@@ -146,6 +150,8 @@ public slots:
 	void MaximizeElseActions();
 	void MinimizeConditions();
 	void MaximizeConditions();
+	void SetElseActionsStateToHidden();
+	void SetElseActionsStateToVisible();
 	void MacroActionSelectionChanged(int idx);
 	void MacroActionReorder(int to, int target);
 	void AddMacroAction(int idx);
@@ -334,7 +340,7 @@ public slots:
 	void on_timeUp_clicked();
 	void on_timeDown_clicked();

-	// Video tab
+	// Audio tab
 public:
 	void SetupAudioTab();
 public slots:
--- a/src/general.cpp
+++ b/src/general.cpp
@@ -33,7 +33,7 @@ void AdvSceneSwitcher::on_noMatchDontSwitch_clicked()
 	}

 	std::lock_guard<std::mutex> lock(switcher->m);
-	switcher->switchIfNotMatching = SwitcherData::NoMatch::NO_SWITCH;
+	switcher->switchIfNotMatching = NoMatchBehavior::NO_SWITCH;
 	ui->noMatchSwitchScene->setEnabled(false);
 	ui->randomDisabledWarning->setVisible(true);
 }
@@ -45,7 +45,7 @@ void AdvSceneSwitcher::on_noMatchSwitch_clicked()
 	}

 	std::lock_guard<std::mutex> lock(switcher->m);
-	switcher->switchIfNotMatching = SwitcherData::NoMatch::SWITCH;
+	switcher->switchIfNotMatching = NoMatchBehavior::SWITCH;
 	ui->noMatchSwitchScene->setEnabled(true);
 	UpdateNonMatchingScene(ui->noMatchSwitchScene->currentText());
 	ui->randomDisabledWarning->setVisible(true);
@@ -58,7 +58,7 @@ void AdvSceneSwitcher::on_noMatchRandomSwitch_clicked()
 	}

 	std::lock_guard<std::mutex> lock(switcher->m);
-	switcher->switchIfNotMatching = SwitcherData::NoMatch::RANDOM_SWITCH;
+	switcher->switchIfNotMatching = NoMatchBehavior::RANDOM_SWITCH;
 	ui->noMatchSwitchScene->setEnabled(false);
 	ui->randomDisabledWarning->setVisible(false);
 }
@@ -506,7 +506,6 @@ void SwitcherData::LoadSettings(obs_data_t *obj)
 	// selections to be available.
 	loadSceneGroups(obj);
 	LoadVariables(obj);
-	LoadConnections(obj);

 	for (const auto &func : loadSteps) {
 		func(obj);
@@ -549,7 +548,6 @@ void SwitcherData::SaveSettings(obs_data_t *obj)

 	saveSceneGroups(obj);
 	SaveMacros(obj);
-	SaveConnections(obj);
 	SaveVariables(obj);
 	saveWindowTitleSwitches(obj);
 	saveScreenRegionSwitches(obj);
@@ -624,9 +622,9 @@ void SwitcherData::LoadGeneralSettings(obs_data_t *obj)
 	interval = obs_data_get_int(obj, "interval");

 	obs_data_set_default_int(obj, "switch_if_not_matching",
-				 static_cast<int>(NoMatch::NO_SWITCH));
-	switchIfNotMatching =
-		(NoMatch)obs_data_get_int(obj, "switch_if_not_matching");
+				 static_cast<int>(NoMatchBehavior::NO_SWITCH));
+	switchIfNotMatching = static_cast<NoMatchBehavior>(
+		obs_data_get_int(obj, "switch_if_not_matching"));
 	std::string nonMatchingSceneName =
 		obs_data_get_string(obj, "non_matching_scene");
 	nonMatchingScene = GetWeakSourceByName(nonMatchingSceneName.c_str());
@@ -800,12 +798,13 @@ void SwitcherData::CheckNoMatchSwitch(bool &match, OBSWeakSource &scene,
 		return;
 	}

-	if (switchIfNotMatching == NoMatch::SWITCH && nonMatchingScene) {
+	if (switchIfNotMatching == NoMatchBehavior::SWITCH &&
+	    nonMatchingScene) {
 		match = true;
 		scene = nonMatchingScene;
 		transition = nullptr;
 	}
-	if (switchIfNotMatching == NoMatch::RANDOM_SWITCH) {
+	if (switchIfNotMatching == NoMatchBehavior::RANDOM_SWITCH) {
 		match = checkRandom(scene, transition, sleep);
 	}
 }
@@ -956,11 +955,11 @@ void AdvSceneSwitcher::SetupGeneralTab()
 {
 	PopulateSceneSelection(ui->noMatchSwitchScene, false);

-	if (switcher->switchIfNotMatching == SwitcherData::NoMatch::SWITCH) {
+	if (switcher->switchIfNotMatching == NoMatchBehavior::SWITCH) {
 		ui->noMatchSwitch->setChecked(true);
 		ui->noMatchSwitchScene->setEnabled(true);
 	} else if (switcher->switchIfNotMatching ==
-		   SwitcherData::NoMatch::NO_SWITCH) {
+		   NoMatchBehavior::NO_SWITCH) {
 		ui->noMatchDontSwitch->setChecked(true);
 		ui->noMatchSwitchScene->setEnabled(false);
 	} else {
--- a/src/legacy/switch-random.cpp
+++ b/src/legacy/switch-random.cpp
@@ -143,8 +143,7 @@ void AdvSceneSwitcher::SetupRandomTab()
 		border-radius: 7px; \
 		border-color: rgb(0,0,0,0) \
 		}");
-	if (switcher->switchIfNotMatching !=
-	    SwitcherData::NoMatch::RANDOM_SWITCH) {
+	if (switcher->switchIfNotMatching != NoMatchBehavior::RANDOM_SWITCH) {
 		if (!switcher->disableHints) {
 			PulseWidget(ui->randomDisabledWarning, QColor(Qt::red),
 				    QColor(0, 0, 0, 0));
--- a/src/linux/advanced-scene-switcher-nix.cpp
+++ b/src/linux/advanced-scene-switcher-nix.cpp
@@ -1,5 +1,6 @@
 #include "platform-funcs.hpp"
 #include "hotkey.hpp"
+#include "log-helper.hpp"

 #include <X11/Xlib.h>
 #include <X11/Xatom.h>
@@ -25,9 +26,10 @@
 #include <QStringList>
 #include <QRegularExpression>
 #include <QLibrary>
-#ifdef USE_PROCPS
+#ifdef PROCPS_AVAILABLE
 #include <proc/readproc.h>
-#else
+#endif
+#ifdef PROCPS2_AVAILABLE
 #include <libproc2/pids.h>
 #endif
 #include <fstream>
@@ -53,6 +55,31 @@ std::chrono::high_resolution_clock::time_point lastMouseLeftClickTime{};
 std::chrono::high_resolution_clock::time_point lastMouseMiddleClickTime{};
 std::chrono::high_resolution_clock::time_point lastMouseRightClickTime{};

+static QLibrary *libprocps = nullptr;
+#ifdef PROCPS_AVAILABLE
+typedef PROCTAB *(*openproc_func)(int flags);
+typedef void (*closeproc_func)(PROCTAB *PT);
+typedef proc_t *(*readproc_func)(PROCTAB *__restrict const PT,
+				 proc_t *__restrict p);
+static openproc_func openproc_ = nullptr;
+static closeproc_func closeproc_ = nullptr;
+static readproc_func readproc_ = nullptr;
+#endif
+static bool libprocpsSupported = false;
+
+static QLibrary *libproc2 = nullptr;
+#ifdef PROCPS2_AVAILABLE
+typedef int (*procps_pids_new_func)(struct pids_info **info,
+				    enum pids_item *items, int numitems);
+typedef struct pids_stack *(*procps_pids_get_func)(struct pids_info *info,
+						   enum pids_fetch_type which);
+typedef int (*procps_pids_unref_func)(struct pids_info **info);
+static procps_pids_new_func procps_pids_new_ = nullptr;
+static procps_pids_get_func procps_pids_get_ = nullptr;
+static procps_pids_unref_func procps_pids_unref_ = nullptr;
+#endif
+static bool libprocps2Supported = false;
+
 Display *disp()
 {
 	if (!xdisplay) {
@@ -338,46 +365,57 @@ std::optional<std::string> GetTextInWindow(const std::string &)
 	return {};
 }

-#ifdef USE_PROCPS
-void GetProcessList(QStringList &processes)
+static void getProcessListProcps(QStringList &processes)
 {
-	processes.clear();
-	PROCTAB *proc = openproc(PROC_FILLSTAT);
+#ifdef PROCPS_AVAILABLE
+	PROCTAB *proc = openproc_(PROC_FILLSTAT);
 	proc_t proc_info;
 	memset(&proc_info, 0, sizeof(proc_info));
-	while (readproc(proc, &proc_info) != NULL) {
+	while (readproc_(proc, &proc_info) != NULL) {
 		QString procName(proc_info.cmd);
 		if (!procName.isEmpty() && !processes.contains(procName)) {
 			processes << procName;
 		}
 	}
-	closeproc(proc);
+	closeproc_(proc);
+#endif
 }
-#else
-void GetProcessList(QStringList &processes)
+
+static void getProcessListProcps2(QStringList &processes)
 {
-	processes.clear();
+#ifdef PROCPS2_AVAILABLE
 	struct pids_info *info = NULL;
 	struct pids_stack *stack;
 	enum pids_item Items[] = {
 		PIDS_CMD,
 	};

-	if (procps_pids_new(&info, Items, sizeof(Items) / sizeof(Items[0])) <
+	if (procps_pids_new_(&info, Items, sizeof(Items) / sizeof(Items[0])) <
 	    0) {
 		return;
 	}
-
-	while ((stack = procps_pids_get(info, PIDS_FETCH_TASKS_ONLY))) {
+	while ((stack = procps_pids_get_(info, PIDS_FETCH_TASKS_ONLY))) {
 		auto cmd = PIDS_VAL(0, str, stack, info);
 		QString procName(cmd);
 		if (!procName.isEmpty() && !processes.contains(procName)) {
 			processes << procName;
 		}
 	}
-	procps_pids_unref(&info);
-}
+	procps_pids_unref_(&info);
 #endif
+}
+
+void GetProcessList(QStringList &processes)
+{
+	processes.clear();
+	if (libprocpsSupported) {
+		getProcessListProcps(processes);
+		return;
+	}
+	if (libprocps2Supported) {
+		getProcessListProcps2(processes);
+	}
+}

 long getForegroundProcessPid()
 {
@@ -633,6 +671,58 @@ void PressKeys(const std::vector<HotkeyType> keys, int duration)
 	XFlush(display);
 }

+static void initXtst()
+{
+	libXtstHandle = new QLibrary("libXtst", nullptr);
+	pressFunc = (keyPressFunc)libXtstHandle->resolve("XTestFakeKeyEvent");
+	int _;
+	canSimulateKeyPresses = pressFunc &&
+				XQueryExtension(disp(), "XTEST", &_, &_, &_);
+}
+
+static void initXss()
+{
+	libXssHandle = new QLibrary("libXss", nullptr);
+	allocSSFunc = (XScreenSaverAllocInfoFunc)libXssHandle->resolve(
+		"XScreenSaverAllocInfo");
+	querySSFunc = (XScreenSaverQueryInfoFunc)libXssHandle->resolve(
+		"XScreenSaverQueryInfo");
+	int _;
+	canGetIdleTime = allocSSFunc && querySSFunc &&
+			 XQueryExtension(disp(), ScreenSaverName, &_, &_, &_);
+}
+
+static void initProcps()
+{
+#ifdef PROCPS_AVAILABLE
+	libprocps = new QLibrary("libprocps", nullptr);
+	openproc_ = (openproc_func)libprocps->resolve("openproc");
+	closeproc_ = (closeproc_func)libprocps->resolve("closeproc");
+	readproc_ = (readproc_func)libprocps->resolve("readproc");
+	if (openproc_ && closeproc_ && readproc_) {
+		libprocpsSupported = true;
+		blog(LOG_INFO, "libprocps symbols resolved successfully!");
+	}
+#endif
+}
+
+static void initProc2()
+{
+#ifdef PROCPS2_AVAILABLE
+	libproc2 = new QLibrary("libproc2", nullptr);
+	procps_pids_new_ =
+		(procps_pids_new_func)libproc2->resolve("procps_pids_new");
+	procps_pids_get_ =
+		(procps_pids_get_func)libproc2->resolve("procps_pids_get");
+	procps_pids_unref_ =
+		(procps_pids_unref_func)libproc2->resolve("procps_pids_unref");
+	if (procps_pids_new_ && procps_pids_get_ && procps_pids_unref_) {
+		libprocps2Supported = true;
+		blog(LOG_INFO, "libproc2 symbols resolved successfully!");
+	}
+#endif
+}
+
 void PlatformInit()
 {
 	auto display = disp();
@@ -640,31 +730,26 @@ void PlatformInit()
 		return;
 	}

-	libXtstHandle = new QLibrary("libXtst", nullptr);
-	pressFunc = (keyPressFunc)libXtstHandle->resolve("XTestFakeKeyEvent");
-	int _;
-	canSimulateKeyPresses = pressFunc &&
-				XQueryExtension(disp(), "XTEST", &_, &_, &_);
+	initXtst();
+	initXss();
+	initProcps();
+	initProc2();
+}

-	libXssHandle = new QLibrary("libXss", nullptr);
-	allocSSFunc = (XScreenSaverAllocInfoFunc)libXssHandle->resolve(
-		"XScreenSaverAllocInfo");
-	querySSFunc = (XScreenSaverQueryInfoFunc)libXssHandle->resolve(
-		"XScreenSaverQueryInfo");
-	canGetIdleTime = allocSSFunc && querySSFunc &&
-			 XQueryExtension(disp(), ScreenSaverName, &_, &_, &_);
+static void cleanupHelper(QLibrary *lib)
+{
+	if (lib) {
+		delete lib;
+		lib = nullptr;
+	}
 }

 void PlatformCleanup()
 {
-	if (libXtstHandle) {
-		delete libXtstHandle;
-		libXtstHandle = nullptr;
-	}
-	if (libXssHandle) {
-		delete libXssHandle;
-		libXssHandle = nullptr;
-	}
+	cleanupHelper(libXtstHandle);
+	cleanupHelper(libXssHandle);
+	cleanupHelper(libprocps);
+	cleanupHelper(libproc2);
 	cleanupDisplay();
 }

--- a/src/macro-core/macro-action-clipboard.cpp
+++ b/src/macro-core/macro-action-clipboard.cpp
@@ -0,0 +1,257 @@
+#include "macro-action-clipboard.hpp"
+#include "curl-helper.hpp"
+#include "switcher-data.hpp"
+
+#include <QApplication>
+#include <QClipboard>
+#include <QImage>
+#include <QMimeData>
+
+namespace advss {
+
+const std::string MacroActionClipboard::id = "clipboard";
+
+bool MacroActionClipboard::_registered = MacroActionFactory::Register(
+	MacroActionClipboard::id,
+	{MacroActionClipboard::Create, MacroActionClipboardEdit::Create,
+	 "AdvSceneSwitcher.action.clipboard"});
+
+const static std::map<MacroActionClipboard::Action, std::string> actionTypes = {
+	{MacroActionClipboard::Action::COPY_TEXT,
+	 "AdvSceneSwitcher.action.clipboard.type.copy.text"},
+	{MacroActionClipboard::Action::COPY_IMAGE,
+	 "AdvSceneSwitcher.action.clipboard.type.copy.image"},
+};
+
+static size_t writeCallback(void *ptr, size_t size, size_t nmemb,
+			    QByteArray *buffer)
+{
+	buffer->append((char *)ptr, nmemb);
+	return size * nmemb;
+}
+
+static std::optional<QImage> getImageFromUrl(const char *url)
+{
+	QByteArray response;
+
+	switcher->curl.SetOpt(CURLOPT_URL, url);
+	switcher->curl.SetOpt(CURLOPT_HTTPGET, 1L);
+	switcher->curl.SetOpt(CURLOPT_TIMEOUT_MS, 30000);
+	switcher->curl.SetOpt(CURLOPT_WRITEFUNCTION, writeCallback);
+	switcher->curl.SetOpt(CURLOPT_WRITEDATA, &response);
+	auto code = switcher->curl.Perform();
+
+	if (code != CURLE_OK) {
+		blog(LOG_WARNING,
+		     "Retrieving image failed in %s with error: %s", __func__,
+		     switcher->curl.GetError(code));
+		return {};
+	}
+
+	return QImage::fromData(response);
+}
+
+static void setMimeTypeParams(ClipboardQueueParams *params,
+			      QClipboard *clipboard)
+{
+	auto mimeData = clipboard->mimeData();
+	if (!mimeData) {
+		return;
+	}
+	auto mimeTypeList = mimeData->formats();
+	if (mimeTypeList.empty()) {
+		return;
+	}
+	params->mimeTypePrimary = mimeTypeList.first().toStdString();
+	params->mimeTypeAll = mimeTypeList.join(" ").toStdString();
+}
+
+static void copyText(void *param)
+{
+	auto params = static_cast<ClipboardTextQueueParams *>(param);
+	QClipboard *clipboard = QApplication::clipboard();
+
+	clipboard->setText(params->text.c_str());
+
+	setMimeTypeParams(params, clipboard);
+}
+
+static void copyImageFromUrl(void *param)
+{
+	auto params = static_cast<ClipboardImageQueueParams *>(param);
+	auto url = params->url.c_str();
+	auto image = getImageFromUrl(url);
+
+	if (!image || (*image).isNull()) {
+		blog(LOG_WARNING, "Failed to convert %s URL to image!", url);
+		return;
+	}
+
+	QClipboard *clipboard = QApplication::clipboard();
+	clipboard->setImage(*image);
+
+	setMimeTypeParams(params, clipboard);
+}
+
+bool MacroActionClipboard::PerformAction()
+{
+	switch (_action) {
+	case Action::COPY_TEXT: {
+		ClipboardTextQueueParams params{"", "", _text};
+		obs_queue_task(OBS_TASK_UI, copyText, &params, true);
+		SetTempVarValues(params);
+		break;
+	}
+	case Action::COPY_IMAGE: {
+		ClipboardImageQueueParams params{"", "", _url};
+		obs_queue_task(OBS_TASK_UI, copyImageFromUrl, &params, true);
+		SetTempVarValues(params);
+		break;
+	}
+	default:
+		break;
+	}
+
+	return true;
+}
+
+void MacroActionClipboard::SetupTempVars()
+{
+	MacroAction::SetupTempVars();
+
+	AddTempvar(
+		"mimeType.primary",
+		obs_module_text(
+			"AdvSceneSwitcher.tempVar.clipboard.mimeType.primary"),
+		obs_module_text(
+			"AdvSceneSwitcher.tempVar.clipboard.mimeType.primary.description"));
+	AddTempvar(
+		"mimeType.all",
+		obs_module_text(
+			"AdvSceneSwitcher.tempVar.clipboard.mimeType.all"),
+		obs_module_text(
+			"AdvSceneSwitcher.tempVar.clipboard.mimeType.all.description"));
+}
+
+void MacroActionClipboard::SetTempVarValues(const ClipboardQueueParams &params)
+{
+	SetTempVarValue("mimeType.primary", params.mimeTypePrimary);
+	SetTempVarValue("mimeType.all", params.mimeTypeAll);
+}
+
+bool MacroActionClipboard::Save(obs_data_t *obj) const
+{
+	MacroAction::Save(obj);
+	obs_data_set_int(obj, "action", static_cast<int>(_action));
+	_text.Save(obj, "text");
+	_url.Save(obj, "url");
+
+	return true;
+}
+
+bool MacroActionClipboard::Load(obs_data_t *obj)
+{
+	MacroAction::Load(obj);
+	_action = static_cast<Action>(obs_data_get_int(obj, "action"));
+	_text.Load(obj, "text");
+	_url.Load(obj, "url");
+
+	return true;
+}
+
+static inline void populateActionSelection(QComboBox *list)
+{
+	for (const auto &[action, name] : actionTypes) {
+		list->addItem(obs_module_text(name.c_str()),
+			      static_cast<int>(action));
+	}
+}
+
+MacroActionClipboardEdit::MacroActionClipboardEdit(
+	QWidget *parent, std::shared_ptr<MacroActionClipboard> entryData)
+	: QWidget(parent),
+	  _actions(new FilterComboBox(this)),
+	  _text(new VariableLineEdit(this)),
+	  _url(new VariableLineEdit(this))
+{
+	populateActionSelection(_actions);
+	_url->setToolTip(obs_module_text(
+		"AdvSceneSwitcher.action.clipboard.copy.image.url.tooltip"));
+
+	QWidget::connect(_actions, SIGNAL(currentIndexChanged(int)), this,
+			 SLOT(ActionChanged(int)));
+	QWidget::connect(_text, SIGNAL(editingFinished()), this,
+			 SLOT(TextChanged()));
+	QWidget::connect(_url, SIGNAL(editingFinished()), this,
+			 SLOT(UrlChanged()));
+
+	auto mainLayout = new QHBoxLayout();
+	mainLayout->addWidget(_actions);
+	mainLayout->addWidget(_text);
+	mainLayout->addWidget(_url);
+	setLayout(mainLayout);
+
+	_entryData = entryData;
+	UpdateEntryData();
+	_loading = false;
+}
+
+void MacroActionClipboardEdit::ActionChanged(int index)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	auto lock = LockContext();
+	_entryData->_action = static_cast<MacroActionClipboard::Action>(
+		_actions->itemData(index).toInt());
+
+	SetWidgetVisibility();
+}
+
+void MacroActionClipboardEdit::TextChanged()
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	auto lock = LockContext();
+	_entryData->_text = _text->text().toStdString();
+}
+
+void MacroActionClipboardEdit::UrlChanged()
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	auto lock = LockContext();
+	_entryData->_url = _url->text().toStdString();
+}
+
+void MacroActionClipboardEdit::SetWidgetVisibility()
+{
+	_text->setVisible(_entryData->_action ==
+			  MacroActionClipboard::Action::COPY_TEXT);
+	_url->setVisible(_entryData->_action ==
+			 MacroActionClipboard::Action::COPY_IMAGE);
+
+	adjustSize();
+	updateGeometry();
+}
+
+void MacroActionClipboardEdit::UpdateEntryData()
+{
+	if (!_entryData) {
+		return;
+	}
+
+	_actions->setCurrentIndex(
+		_actions->findData(static_cast<int>(_entryData->_action)));
+	_text->setText(_entryData->_text);
+	_url->setText(_entryData->_url);
+
+	SetWidgetVisibility();
+}
+
+} // namespace advss
--- a/src/macro-core/macro-action-clipboard.hpp
+++ b/src/macro-core/macro-action-clipboard.hpp
@@ -0,0 +1,89 @@
+#pragma once
+#include "macro-action-edit.hpp"
+#include "filter-combo-box.hpp"
+
+#include <variable-line-edit.hpp>
+
+namespace advss {
+
+struct ClipboardQueueParams {
+	std::string mimeTypePrimary;
+	std::string mimeTypeAll;
+};
+
+struct ClipboardTextQueueParams : ClipboardQueueParams {
+	StringVariable text;
+};
+
+struct ClipboardImageQueueParams : ClipboardQueueParams {
+	StringVariable url;
+};
+
+class MacroActionClipboard : public MacroAction {
+public:
+	MacroActionClipboard(Macro *m) : MacroAction(m) {}
+	static std::shared_ptr<MacroAction> Create(Macro *m)
+	{
+		return std::make_shared<MacroActionClipboard>(m);
+	}
+	std::string GetId() const { return id; };
+
+	bool PerformAction();
+	bool Save(obs_data_t *obj) const;
+	bool Load(obs_data_t *obj);
+
+	enum class Action {
+		COPY_TEXT,
+		COPY_IMAGE,
+	};
+
+	Action _action = Action::COPY_TEXT;
+
+	StringVariable _text = obs_module_text(
+		"AdvSceneSwitcher.action.clipboard.copy.text.text.placeholder");
+	StringVariable _url = obs_module_text(
+		"AdvSceneSwitcher.action.clipboard.copy.image.url.placeholder");
+
+private:
+	void SetupTempVars();
+	void SetTempVarValues(const ClipboardQueueParams &params);
+
+	static bool _registered;
+	static const std::string id;
+};
+
+class MacroActionClipboardEdit : public QWidget {
+	Q_OBJECT
+
+public:
+	MacroActionClipboardEdit(
+		QWidget *parent,
+		std::shared_ptr<MacroActionClipboard> entryData = nullptr);
+	static QWidget *Create(QWidget *parent,
+			       std::shared_ptr<MacroAction> action)
+	{
+		return new MacroActionClipboardEdit(
+			parent, std::dynamic_pointer_cast<MacroActionClipboard>(
+					action));
+	}
+	void UpdateEntryData();
+
+protected:
+	std::shared_ptr<MacroActionClipboard> _entryData;
+
+private slots:
+	void ActionChanged(int index);
+	void TextChanged();
+	void UrlChanged();
+
+private:
+	void SetWidgetVisibility();
+
+	bool _loading = true;
+
+	FilterComboBox *_actions;
+	VariableLineEdit *_text;
+	VariableLineEdit *_url;
+};
+
+} // namespace advss
--- a/src/macro-core/macro-action-filter.cpp
+++ b/src/macro-core/macro-action-filter.cpp
@@ -424,11 +424,16 @@ void MacroActionFilterEdit::SetWidgetVisibility()
 			      _entryData->_settingsInputMethod ==
 				      MacroActionFilter::SettingsInputMethod::
 					      INDIVIDUAL_TEMPVAR);
-	_manualSettingValue->setVisible(
-		_entryData->_action == MacroActionFilter::Action::SETTINGS &&
-		_entryData->_settingsInputMethod ==
-			MacroActionFilter::SettingsInputMethod::
-				INDIVIDUAL_MANUAL);
+
+	if (_entryData->_action == MacroActionFilter::Action::SETTINGS &&
+	    _entryData->_settingsInputMethod ==
+		    MacroActionFilter::SettingsInputMethod::INDIVIDUAL_MANUAL) {
+		RemoveStretchIfPresent(_settingsLayout);
+		_manualSettingValue->show();
+	} else {
+		AddStretchIfNecessary(_settingsLayout);
+		_manualSettingValue->hide();
+	}

 	adjustSize();
 	updateGeometry();
--- a/src/macro-core/macro-action-plugin-state.cpp
+++ b/src/macro-core/macro-action-plugin-state.cpp
@@ -1,8 +1,9 @@
 #include "macro-action-plugin-state.hpp"
-#include "switcher-data.hpp"
+#include "plugin-state-helper.hpp"
 #include "utility.hpp"

 #include <thread>
+#include <condition_variable>
 #include <QMainWindow>

 using namespace std::chrono_literals;
@@ -27,40 +28,38 @@ const static std::map<PluginStateAction, std::string> actionTypes = {
 	 "AdvSceneSwitcher.action.pluginState.type.terminate"},
 };

-const static std::map<SwitcherData::NoMatch, std::string> noMatchValues = {
-	{SwitcherData::NoMatch::NO_SWITCH,
+const static std::map<NoMatchBehavior, std::string> noMatchValues = {
+	{NoMatchBehavior::NO_SWITCH,
 	 "AdvSceneSwitcher.generalTab.generalBehavior.onNoMet.dontSwitch"},
-	{SwitcherData::NoMatch::SWITCH,
+	{NoMatchBehavior::SWITCH,
 	 "AdvSceneSwitcher.generalTab.generalBehavior.onNoMet.switchTo"},
-	{SwitcherData::NoMatch::RANDOM_SWITCH,
+	{NoMatchBehavior::RANDOM_SWITCH,
 	 "AdvSceneSwitcher.generalTab.generalBehavior.onNoMet.switchToRandom"},
 };

 static void stopPlugin()
 {
-	std::thread t([]() { switcher->Stop(); });
+	std::thread t([]() { StopPlugin(); });
 	t.detach();
 }

 static void importSettings(const std::string &path)
 {
-	if (switcher->settingsWindowOpened) {
+	if (SettingsWindowIsOpened()) {
 		return;
 	}
-	obs_data_t *obj = obs_data_create_from_json_file(path.c_str());
+	OBSDataAutoRelease obj = obs_data_create_from_json_file(path.c_str());
 	if (!obj) {
 		return;
 	}
-	switcher->LoadSettings(obj);
-	obs_data_release(obj);
+	LoadPluginSettings(obj);
 }

 static void setNoMatchBehaviour(int value, OBSWeakSource &scene)
 {
-	switcher->switchIfNotMatching =
-		static_cast<SwitcherData::NoMatch>(value);
-	if (switcher->switchIfNotMatching == SwitcherData::NoMatch::SWITCH) {
-		switcher->nonMatchingScene = scene;
+	SetPluginNoMatchBehavior(static_cast<NoMatchBehavior>(value));
+	if (GetPluginNoMatchBehavior() == NoMatchBehavior::SWITCH) {
+		SetNoMatchScene(scene);
 	}
 }

@@ -342,8 +341,8 @@ void MacroActionPluginStateEdit::SetWidgetVisibility()
 		break;
 	case PluginStateAction::NO_MATCH_BEHAVIOUR:
 		_values->show();
-		if (static_cast<SwitcherData::NoMatch>(_entryData->_value) ==
-		    SwitcherData::NoMatch::SWITCH) {
+		if (static_cast<NoMatchBehavior>(_entryData->_value) ==
+		    NoMatchBehavior::SWITCH) {
 			_scenes->show();
 		}
 		break;
--- a/src/macro-core/macro-action-scene-collection.cpp
+++ b/src/macro-core/macro-action-scene-collection.cpp
@@ -1,5 +1,5 @@
 #include "macro-action-scene-collection.hpp"
-#include "switcher-data.hpp"
+#include "plugin-state-helper.hpp"
 #include "utility.hpp"

 namespace advss {
@@ -17,7 +17,7 @@ bool MacroActionSceneCollection::PerformAction()
 	// Changing the scene collection will also reload the settings of the
 	// scene switcher, so to avoid issues of not being able to change
 	// settings ignore this action if the settings dialog is opened.
-	if (switcher->settingsWindowOpened) {
+	if (SettingsWindowIsOpened()) {
 		return false;
 	}
 	obs_frontend_set_current_scene_collection(_sceneCollection.c_str());
--- a/src/macro-core/macro-action-scene-switch.cpp
+++ b/src/macro-core/macro-action-scene-switch.cpp
@@ -145,7 +145,8 @@ bool MacroActionSwitchScene::PerformAction()
 	auto transition = _transition.GetTransition();
 	SwitchScene({scene, transition, (int)(_duration.Milliseconds())},
 		    obs_frontend_preview_program_mode_active());
-	if (_blockUntilTransitionDone && scene) {
+	if (_blockUntilTransitionDone && scene &&
+	    scene != switcher->currentScene) {
 		return WaitForTransition(scene, transition);
 	}
 	return true;
--- a/src/macro-core/macro-action-screenshot.cpp
+++ b/src/macro-core/macro-action-screenshot.cpp
@@ -32,7 +32,7 @@ void MacroActionScreenshot::CustomScreenshot(OBSWeakSource &source)
 	}
 	auto s = obs_weak_source_get_source(source);
 	_screenshot.~ScreenshotHelper();
-	new (&_screenshot) ScreenshotHelper(s, false, 0, true, _path);
+	new (&_screenshot) ScreenshotHelper(s, QRect(), false, 0, true, _path);
 	obs_source_release(s);
 }

--- a/src/macro-core/macro-action-source.cpp
+++ b/src/macro-core/macro-action-source.cpp
@@ -601,11 +601,17 @@ void MacroActionSourceEdit::SetWidgetVisibility()
 			      _entryData->_settingsInputMethod ==
 				      MacroActionSource::SettingsInputMethod::
 					      INDIVIDUAL_TEMPVAR);
-	_manualSettingValue->setVisible(
-		_entryData->_action == MacroActionSource::Action::SETTINGS &&
-		_entryData->_settingsInputMethod ==
-			MacroActionSource::SettingsInputMethod::
-				INDIVIDUAL_MANUAL);
+
+	if (_entryData->_action == MacroActionSource::Action::SETTINGS &&
+	    _entryData->_settingsInputMethod ==
+		    MacroActionSource::SettingsInputMethod::INDIVIDUAL_MANUAL) {
+		RemoveStretchIfPresent(_settingsLayout);
+		_manualSettingValue->show();
+	} else {
+		AddStretchIfNecessary(_settingsLayout);
+		_manualSettingValue->hide();
+	}
+
 	const bool showWarning =
 		_entryData->_action == MacroActionSource::Action::ENABLE ||
 		_entryData->_action == MacroActionSource::Action::DISABLE;
--- a/src/macro-core/macro-condition-audio.cpp
+++ b/src/macro-core/macro-condition-audio.cpp
@@ -62,17 +62,17 @@ MacroConditionAudio::~MacroConditionAudio()
 bool MacroConditionAudio::CheckOutputCondition()
 {
 	bool ret = false;
-	auto s = obs_weak_source_get_source(_audioSource.GetSource());
+	OBSSourceAutoRelease source =
+		obs_weak_source_get_source(_audioSource.GetSource());

+	// peak will have a value from -60 db to 0 db so we need to scale it
 	double curVolume = ((double)_peak + 60) * 1.7;

 	switch (_outputCondition) {
 	case OutputCondition::ABOVE:
-		// peak will have a value from -60 db to 0 db
 		ret = curVolume > _volume;
 		break;
 	case OutputCondition::BELOW:
-		// peak will have a value from -60 db to 0 db
 		ret = curVolume < _volume;
 		break;
 	default:
@@ -84,21 +84,21 @@ bool MacroConditionAudio::CheckOutputCondition()

 	// Reset for next check
 	_peak = -std::numeric_limits<float>::infinity();
-	obs_source_release(s);
 	if (_audioSource.GetType() == SourceSelection::Type::VARIABLE) {
 		ResetVolmeter();
 	}

-	return ret;
+	return ret && source;
 }

 bool MacroConditionAudio::CheckVolumeCondition()
 {
 	bool ret = false;
-	auto s = obs_weak_source_get_source(_audioSource.GetSource());
+	OBSSourceAutoRelease source =
+		obs_weak_source_get_source(_audioSource.GetSource());

-	float curVolume = obs_source_get_volume(s);
-	bool muted = obs_source_muted(s);
+	float curVolume = obs_source_get_volume(source);
+	bool muted = obs_source_muted(source);

 	switch (_volumeCondition) {
 	case VolumeCondition::ABOVE:
@@ -126,10 +126,9 @@ bool MacroConditionAudio::CheckVolumeCondition()
 	}

 	SetTempVarValue("configured_volume", std::to_string(curVolume));
-	SetTempVarValue("muted", muted ? "true" : "false");
+	SetTempVarValue("muted", (source && muted) ? "true" : "false");

-	obs_source_release(s);
-	return ret;
+	return ret && source;
 }

 bool MacroConditionAudio::CheckSyncOffset()
@@ -139,8 +138,9 @@ bool MacroConditionAudio::CheckSyncOffset()
 	}

 	bool ret = false;
-	auto s = obs_weak_source_get_source(_audioSource.GetSource());
-	auto curOffset = obs_source_get_sync_offset(s) / nsPerMs;
+	OBSSourceAutoRelease source =
+		obs_weak_source_get_source(_audioSource.GetSource());
+	auto curOffset = obs_source_get_sync_offset(source) / nsPerMs;
 	if (_outputCondition == OutputCondition::ABOVE) {
 		ret = curOffset > _syncOffset;
 	} else {
@@ -148,8 +148,7 @@ bool MacroConditionAudio::CheckSyncOffset()
 	}
 	SetVariableValue(std::to_string(curOffset));
 	SetTempVarValue("sync_offset", std::to_string(curOffset));
-	obs_source_release(s);
-	return ret;
+	return ret && source;
 }

 bool MacroConditionAudio::CheckMonitor()
@@ -159,13 +158,13 @@ bool MacroConditionAudio::CheckMonitor()
 	}

 	bool ret = false;
-	auto s = obs_weak_source_get_source(_audioSource.GetSource());
-	ret = obs_source_get_monitoring_type(s) == _monitorType;
+	OBSSourceAutoRelease source =
+		obs_weak_source_get_source(_audioSource.GetSource());
+	ret = obs_source_get_monitoring_type(source) == _monitorType;
 	SetVariableValue("");
 	SetTempVarValue("monitor",
-			std::to_string(obs_source_get_monitoring_type(s)));
-	obs_source_release(s);
-	return ret;
+			std::to_string(obs_source_get_monitoring_type(source)));
+	return ret && source;
 }

 bool MacroConditionAudio::CheckBalance()
@@ -175,8 +174,9 @@ bool MacroConditionAudio::CheckBalance()
 	}

 	bool ret = false;
-	auto s = obs_weak_source_get_source(_audioSource.GetSource());
-	auto curBalance = obs_source_get_balance_value(s);
+	OBSSourceAutoRelease source =
+		obs_weak_source_get_source(_audioSource.GetSource());
+	auto curBalance = obs_source_get_balance_value(source);
 	if (_outputCondition == OutputCondition::ABOVE) {
 		ret = curBalance > _balance;
 	} else {
@@ -184,8 +184,7 @@ bool MacroConditionAudio::CheckBalance()
 	}
 	SetVariableValue(std::to_string(curBalance));
 	SetTempVarValue("balance", std::to_string(curBalance));
-	obs_source_release(s);
-	return ret;
+	return ret && source;
 }

 bool MacroConditionAudio::CheckCondition()
@@ -239,13 +238,12 @@ obs_volmeter_t *AddVolmeterToSource(MacroConditionAudio *entry,
 	obs_volmeter_t *volmeter = obs_volmeter_create(OBS_FADER_LOG);
 	obs_volmeter_add_callback(volmeter, MacroConditionAudio::SetVolumeLevel,
 				  entry);
-	obs_source_t *as = obs_weak_source_get_source(source);
-	if (!obs_volmeter_attach_source(volmeter, as)) {
-		const char *name = obs_source_get_name(as);
+	OBSSourceAutoRelease audioSource = obs_weak_source_get_source(source);
+	if (!obs_volmeter_attach_source(volmeter, audioSource)) {
+		const char *name = obs_source_get_name(audioSource);
 		blog(LOG_WARNING, "failed to attach volmeter to source %s",
 		     name);
 	}
-	obs_source_release(as);

 	return volmeter;
 }
@@ -455,10 +453,9 @@ MacroConditionAudioEdit::MacroConditionAudioEdit(
 void MacroConditionAudioEdit::UpdateVolmeterSource()
 {
 	delete _volMeter;
-	obs_source_t *soruce = obs_weak_source_get_source(
+	OBSSourceAutoRelease soruce = obs_weak_source_get_source(
 		_entryData->_audioSource.GetSource());
-	_volMeter = new VolControl(soruce);
-	obs_source_release(soruce);
+	_volMeter = new VolControl(soruce.Get());

 	QLayout *layout = this->layout();
 	layout->addWidget(_volMeter);
--- a/src/macro-core/macro-condition-macro.cpp
+++ b/src/macro-core/macro-condition-macro.cpp
@@ -24,6 +24,8 @@ const static std::map<MacroConditionMacro::Type, std::string>
 		 "AdvSceneSwitcher.condition.macro.type.actionDisabled"},
 		{MacroConditionMacro::Type::ACTION_ENABLED,
 		 "AdvSceneSwitcher.condition.macro.type.actionEnabled"},
+		{MacroConditionMacro::Type::PAUSED,
+		 "AdvSceneSwitcher.condition.macro.type.paused"},
 };

 const static std::map<MacroConditionMacro::CounterCondition, std::string>
@@ -75,6 +77,8 @@ bool MacroConditionMacro::CheckMultiStateCondition()
 		}
 	}

+	SetTempVarValue("matchedCount", std::to_string(matchedCount));
+
 	switch (_multiSateCondition) {
 	case MacroConditionMacro::MultiStateCondition::BELOW:
 		return matchedCount < _multiSateCount;
@@ -107,6 +111,16 @@ bool MacroConditionMacro::CheckActionStateCondition()
 	return false;
 }

+bool MacroConditionMacro::CheckPauseState()
+{
+	auto macro = _macro.GetMacro();
+	if (!macro) {
+		return false;
+	}
+
+	return macro->Paused();
+}
+
 bool MacroConditionMacro::CheckCountCondition()
 {
 	auto macro = _macro.GetMacro();
@@ -114,6 +128,8 @@ bool MacroConditionMacro::CheckCountCondition()
 		return false;
 	}

+	SetTempVarValue("runCount", std::to_string(macro->RunCount()));
+
 	switch (_counterCondition) {
 	case CounterCondition::BELOW:
 		return macro->RunCount() < _count;
@@ -140,6 +156,8 @@ bool MacroConditionMacro::CheckCondition()
 	case Type::ACTION_DISABLED:
 	case Type::ACTION_ENABLED:
 		return CheckActionStateCondition();
+	case Type::PAUSED:
+		return CheckPauseState();
 	default:
 		break;
 	}
@@ -193,7 +211,7 @@ bool MacroConditionMacro::Load(obs_data_t *obj)

 bool MacroConditionMacro::PostLoad()
 {
-	return MacroRefCondition::PostLoad() &&
+	return MacroCondition::PostLoad() && MacroRefCondition::PostLoad() &&
 	       MultiMacroRefCondtition::PostLoad();
 }

@@ -202,6 +220,45 @@ std::string MacroConditionMacro::GetShortDesc() const
 	return _macro.Name();
 }

+void MacroConditionMacro::SetType(Type type)
+{
+	_type = type;
+	SetupTempVars();
+}
+
+void MacroConditionMacro::SetupTempVars()
+{
+	MacroCondition::SetupTempVars();
+	switch (_type) {
+	case Type::COUNT:
+		AddTempvar(
+			"runCount",
+			obs_module_text(
+				"AdvSceneSwitcher.tempVar.macro.runCount"),
+			obs_module_text(
+				"AdvSceneSwitcher.tempVar.macro.runCount.description"));
+		break;
+	case Type::STATE:
+		break;
+	case Type::MULTI_STATE:
+		AddTempvar(
+			"matchedCount",
+			obs_module_text(
+				"AdvSceneSwitcher.tempVar.macro.matchedCount"),
+			obs_module_text(
+				"AdvSceneSwitcher.tempVar.macro.matchedCount.description"));
+		break;
+	case Type::ACTION_DISABLED:
+		break;
+	case Type::ACTION_ENABLED:
+		break;
+	case Type::PAUSED:
+		break;
+	default:
+		break;
+	}
+}
+
 static inline void populateTypeSelection(QComboBox *list)
 {
 	for (auto entry : macroConditionTypes) {
@@ -335,7 +392,10 @@ void MacroConditionMacroEdit::ClearLayouts()

 void MacroConditionMacroEdit::SetupWidgets()
 {
-	switch (_entryData->_type) {
+	SetWidgetVisibility();
+	ClearLayouts();
+
+	switch (_entryData->GetType()) {
 	case MacroConditionMacro::Type::COUNT:
 		SetupCountWidgets();
 		break;
@@ -351,6 +411,9 @@ void MacroConditionMacroEdit::SetupWidgets()
 	case MacroConditionMacro::Type::ACTION_ENABLED:
 		SetupActionStateWidgets(true);
 		break;
+	case MacroConditionMacro::Type::PAUSED:
+		SetupPauseWidgets();
+		break;
 	default:
 		break;
 	}
@@ -358,38 +421,24 @@ void MacroConditionMacroEdit::SetupWidgets()

 void MacroConditionMacroEdit::SetupStateWidgets()
 {
-	SetWidgetVisibility();
-	ClearLayouts();
-
-	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
-		{"{{macros}}", _macros},
-	};
 	PlaceWidgets(
 		obs_module_text("AdvSceneSwitcher.condition.macro.state.entry"),
-		_settingsLine1, widgetPlaceholders);
+		_settingsLine1, {{"{{macros}}", _macros}});
 }

 void MacroConditionMacroEdit::SetupMultiStateWidgets()
 {
-	SetWidgetVisibility();
-	ClearLayouts();
-
-	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
-		{"{{multiStateConditions}}", _multiStateConditions},
-		{"{{multiStateCount}}", _multiStateCount},
-	};
 	PlaceWidgets(
 		obs_module_text(
 			"AdvSceneSwitcher.condition.macro.multistate.entry"),
-		_settingsLine1, widgetPlaceholders);
+		_settingsLine1,
+		{{"{{multiStateConditions}}", _multiStateConditions},
+		 {"{{multiStateCount}}", _multiStateCount}});
 }

 void MacroConditionMacroEdit::SetupCountWidgets()
 {
-	SetWidgetVisibility();
-	ClearLayouts();
-
-	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
+	const std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
 		{"{{macros}}", _macros},
 		{"{{conditions}}", _counterConditions},
 		{"{{count}}", _count},
@@ -408,9 +457,6 @@ void MacroConditionMacroEdit::SetupCountWidgets()

 void MacroConditionMacroEdit::SetupActionStateWidgets(bool enable)
 {
-	SetWidgetVisibility();
-	ClearLayouts();
-
 	PlaceWidgets(
 		obs_module_text(
 			enable ? "AdvSceneSwitcher.condition.macro.actionState.enabled.entry"
@@ -419,35 +465,49 @@ void MacroConditionMacroEdit::SetupActionStateWidgets(bool enable)
 		{{"{{macros}}", _macros}, {"{{actionIndex}}", _actionIndex}});
 }

+void MacroConditionMacroEdit::SetupPauseWidgets()
+{
+	PlaceWidgets(obs_module_text(
+			     "AdvSceneSwitcher.condition.macro.paused.entry"),
+		     _settingsLine1, {{"{{macros}}", _macros}});
+}
+
 void MacroConditionMacroEdit::SetWidgetVisibility()
 {
 	_macros->setVisible(
-		_entryData->_type == MacroConditionMacro::Type::COUNT ||
-		_entryData->_type == MacroConditionMacro::Type::STATE ||
-		_entryData->_type ==
+		_entryData->GetType() == MacroConditionMacro::Type::COUNT ||
+		_entryData->GetType() == MacroConditionMacro::Type::STATE ||
+		_entryData->GetType() ==
 			MacroConditionMacro::Type::ACTION_DISABLED ||
-		_entryData->_type == MacroConditionMacro::Type::ACTION_ENABLED);
-	_counterConditions->setVisible(_entryData->_type ==
+		_entryData->GetType() ==
+			MacroConditionMacro::Type::ACTION_ENABLED ||
+		_entryData->GetType() == MacroConditionMacro::Type::PAUSED);
+	_counterConditions->setVisible(_entryData->GetType() ==
 				       MacroConditionMacro::Type::COUNT);
-	_count->setVisible(_entryData->_type ==
+	_count->setVisible(_entryData->GetType() ==
 			   MacroConditionMacro::Type::COUNT);
-	_currentCount->setVisible(_entryData->_type ==
+	_currentCount->setVisible(_entryData->GetType() ==
 				  MacroConditionMacro::Type::COUNT);
-	_resetCount->setVisible(_entryData->_type ==
+	_resetCount->setVisible(_entryData->GetType() ==
 				MacroConditionMacro::Type::COUNT);
-	_macroList->setVisible(_entryData->_type ==
+	_macroList->setVisible(_entryData->GetType() ==
 			       MacroConditionMacro::Type::MULTI_STATE);
 	_multiStateConditions->setVisible(
-		_entryData->_type == MacroConditionMacro::Type::MULTI_STATE);
-	_multiStateCount->setVisible(_entryData->_type ==
+		_entryData->GetType() ==
+		MacroConditionMacro::Type::MULTI_STATE);
+	_multiStateCount->setVisible(_entryData->GetType() ==
 				     MacroConditionMacro::Type::MULTI_STATE);
 	_actionIndex->setVisible(
-		_entryData->_type ==
+		_entryData->GetType() ==
 			MacroConditionMacro::Type::ACTION_DISABLED ||
-		_entryData->_type == MacroConditionMacro::Type::ACTION_ENABLED);
-	if (_entryData->_type == MacroConditionMacro::Type::MULTI_STATE ||
-	    _entryData->_type == MacroConditionMacro::Type::ACTION_DISABLED ||
-	    _entryData->_type == MacroConditionMacro::Type::ACTION_ENABLED) {
+		_entryData->GetType() ==
+			MacroConditionMacro::Type::ACTION_ENABLED);
+	if (_entryData->GetType() == MacroConditionMacro::Type::MULTI_STATE ||
+	    _entryData->GetType() ==
+		    MacroConditionMacro::Type::ACTION_DISABLED ||
+	    _entryData->GetType() ==
+		    MacroConditionMacro::Type::ACTION_ENABLED ||
+	    _entryData->GetType() == MacroConditionMacro::Type::PAUSED) {
 		_pausedWarning->hide();
 	}

@@ -463,7 +523,7 @@ void MacroConditionMacroEdit::UpdateEntryData()

 	SetupWidgets();
 	_macros->SetCurrentMacro(_entryData->_macro);
-	_types->setCurrentIndex(static_cast<int>(_entryData->_type));
+	_types->setCurrentIndex(static_cast<int>(_entryData->GetType()));
 	_counterConditions->setCurrentIndex(
 		static_cast<int>(_entryData->_counterCondition));
 	_count->SetValue(_entryData->_count);
@@ -535,7 +595,7 @@ void MacroConditionMacroEdit::TypeChanged(int type)
 	}

 	auto lock = LockContext();
-	_entryData->_type = static_cast<MacroConditionMacro::Type>(type);
+	_entryData->SetType(static_cast<MacroConditionMacro::Type>(type));
 	SetupWidgets();
 }

@@ -571,7 +631,8 @@ void MacroConditionMacroEdit::UpdatePaused()
 	auto macro = _entryData->_macro.GetMacro();
 	_pausedWarning->setVisible(
 		_entryData &&
-		_entryData->_type != MacroConditionMacro::Type::MULTI_STATE &&
+		_entryData->GetType() !=
+			MacroConditionMacro::Type::MULTI_STATE &&
 		macro && macro->Paused());
 	adjustSize();
 	updateGeometry();
--- a/src/macro-core/macro-condition-macro.hpp
+++ b/src/macro-core/macro-condition-macro.hpp
@@ -39,8 +39,10 @@ public:
 		MULTI_STATE,
 		ACTION_DISABLED,
 		ACTION_ENABLED,
+		PAUSED,
 	};
-	Type _type = Type::STATE;
+	void SetType(Type);
+	Type GetType() const { return _type; }

 	enum class CounterCondition {
 		BELOW,
@@ -64,7 +66,11 @@ private:
 	bool CheckStateCondition();
 	bool CheckMultiStateCondition();
 	bool CheckActionStateCondition();
+	bool CheckPauseState();

+	void SetupTempVars();
+
+	Type _type = Type::STATE;
 	static bool _registered;
 	static const std::string id;
 };
@@ -128,6 +134,7 @@ private:
 	void SetupMultiStateWidgets();
 	void SetupCountWidgets();
 	void SetupActionStateWidgets(bool enable);
+	void SetupPauseWidgets();
 	void SetWidgetVisibility();
 	bool _loading = true;
 };
--- a/src/macro-core/macro-condition-process.cpp
+++ b/src/macro-core/macro-condition-process.cpp
@@ -19,25 +19,43 @@ bool MacroConditionProcess::CheckCondition()
 	QStringList runningProcesses;
 	QString proc = QString::fromStdString(_process);
 	GetProcessList(runningProcesses);
+	std::string foregroundProcessName;
+	GetForegroundProcessName(foregroundProcessName);

-	bool equals = runningProcesses.contains(proc);
-	bool matches = runningProcesses.indexOf(QRegularExpression(proc)) != -1;
-	bool focus = !_focus || IsInFocus(proc);
+	SetVariableValue(foregroundProcessName);

-	if (IsReferencedInVars()) {
-		std::string name;
-		GetForegroundProcessName(name);
-		SetVariableValue(name);
+	if (!_regex.Enabled()) {
+		if (runningProcesses.contains(proc) &&
+		    (!_checkFocus || IsInFocus(proc))) {
+			SetTempVarValue("name", proc.toStdString());
+			return true;
+		}
+		return false;
 	}

-	return (equals || matches) && focus;
+	auto matchIndex = runningProcesses.indexOf(QRegularExpression(proc));
+	if (matchIndex == -1) {
+		return false;
+	}
+	if (!_checkFocus) {
+		SetTempVarValue("name",
+				runningProcesses.at(matchIndex).toStdString());
+		return true;
+	}
+	if (!IsInFocus(proc)) {
+		return false;
+	}
+	SetTempVarValue("name", foregroundProcessName);
+	return true;
 }

 bool MacroConditionProcess::Save(obs_data_t *obj) const
 {
 	MacroCondition::Save(obj);
 	obs_data_set_string(obj, "process", _process.c_str());
-	obs_data_set_bool(obj, "focus", _focus);
+	obs_data_set_bool(obj, "focus", _checkFocus);
+	_regex.Save(obj);
+	obs_data_set_int(obj, "version", 1);
 	return true;
 }

@@ -45,7 +63,13 @@ bool MacroConditionProcess::Load(obs_data_t *obj)
 {
 	MacroCondition::Load(obj);
 	_process = obs_data_get_string(obj, "process");
-	_focus = obs_data_get_bool(obj, "focus");
+	_checkFocus = obs_data_get_bool(obj, "focus");
+	// Fall back to partial match regex as default for old version
+	if (!obs_data_has_user_value(obj, "version")) {
+		_regex.SetEnabled(true);
+	} else {
+		_regex.Load(obj);
+	}
 	return true;
 }

@@ -54,10 +78,18 @@ std::string MacroConditionProcess::GetShortDesc() const
 	return _process;
 }

+void MacroConditionProcess::SetupTempVars()
+{
+	MacroCondition::SetupTempVars();
+	AddTempvar("name",
+		   obs_module_text("AdvSceneSwitcher.tempVar.process.name"));
+}
+
 MacroConditionProcessEdit::MacroConditionProcessEdit(
 	QWidget *parent, std::shared_ptr<MacroConditionProcess> entryData)
 	: QWidget(parent),
 	  _processSelection(new QComboBox()),
+	  _regex(new RegexConfigWidget(this)),
 	  _focused(new QCheckBox()),
 	  _focusProcess(new QLabel()),
 	  _focusLayout(new QHBoxLayout())
@@ -68,6 +100,8 @@ MacroConditionProcessEdit::MacroConditionProcessEdit(
 	QWidget::connect(_processSelection,
 			 SIGNAL(currentTextChanged(const QString &)), this,
 			 SLOT(ProcessChanged(const QString &)));
+	QWidget::connect(_regex, SIGNAL(RegexConfigChanged(RegexConfig)), this,
+			 SLOT(RegexChanged(RegexConfig)));
 	QWidget::connect(_focused, SIGNAL(stateChanged(int)), this,
 			 SLOT(FocusChanged(int)));
 	QWidget::connect(&_timer, SIGNAL(timeout()), this,
@@ -77,6 +111,7 @@ MacroConditionProcessEdit::MacroConditionProcessEdit(

 	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
 		{"{{processes}}", _processSelection},
+		{"{{regex}}", _regex},
 		{"{{focused}}", _focused},
 		{"{{focusProcess}}", _focusProcess},
 	};
@@ -112,6 +147,18 @@ void MacroConditionProcessEdit::ProcessChanged(const QString &text)
 		QString::fromStdString(_entryData->GetShortDesc()));
 }

+void MacroConditionProcessEdit::RegexChanged(RegexConfig conf)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	auto lock = LockContext();
+	_entryData->_regex = conf;
+	adjustSize();
+	updateGeometry();
+}
+
 void MacroConditionProcessEdit::FocusChanged(int state)
 {
 	if (_loading || !_entryData) {
@@ -119,7 +166,7 @@ void MacroConditionProcessEdit::FocusChanged(int state)
 	}

 	auto lock = LockContext();
-	_entryData->_focus = state;
+	_entryData->_checkFocus = state;
 	SetWidgetVisibility();
 }

@@ -134,7 +181,7 @@ void MacroConditionProcessEdit::SetWidgetVisibility()
 	if (!_entryData) {
 		return;
 	}
-	SetLayoutVisible(_focusLayout, _entryData->_focus);
+	SetLayoutVisible(_focusLayout, _entryData->_checkFocus);
 	adjustSize();
 }

@@ -145,7 +192,8 @@ void MacroConditionProcessEdit::UpdateEntryData()
 	}

 	_processSelection->setCurrentText(_entryData->_process.c_str());
-	_focused->setChecked(_entryData->_focus);
+	_regex->SetRegexConfig(_entryData->_regex);
+	_focused->setChecked(_entryData->_checkFocus);
 	SetWidgetVisibility();
 }

--- a/src/macro-core/macro-condition-process.hpp
+++ b/src/macro-core/macro-condition-process.hpp
@@ -1,5 +1,6 @@
 #pragma once
 #include "macro-condition-edit.hpp"
+#include "regex-config.hpp"

 #include <QComboBox>
 #include <QCheckBox>
@@ -20,9 +21,12 @@ public:
 	}

 	std::string _process;
-	bool _focus = true;
+	bool _checkFocus = true;
+	RegexConfig _regex = RegexConfig::PartialMatchRegexConfig();

 private:
+	void SetupTempVars();
+
 	static bool _registered;
 	static const std::string id;
 };
@@ -45,22 +49,22 @@ public:

 private slots:
 	void ProcessChanged(const QString &text);
+	void RegexChanged(RegexConfig);
 	void FocusChanged(int state);
 	void UpdateFocusProcess();
 signals:
 	void HeaderInfoChanged(const QString &);

-protected:
+private:
+	void SetWidgetVisibility();
+
 	QComboBox *_processSelection;
+	RegexConfigWidget *_regex;
 	QCheckBox *_focused;
 	QLabel *_focusProcess;
 	QHBoxLayout *_focusLayout;
 	QTimer _timer;
 	std::shared_ptr<MacroConditionProcess> _entryData;
-
-private:
-	void SetWidgetVisibility();
-
 	bool _loading = true;
 };

--- a/src/macro-core/macro-condition-recording.cpp
+++ b/src/macro-core/macro-condition-recording.cpp
@@ -1,6 +1,8 @@
 #include "macro-condition-recording.hpp"
 #include "utility.hpp"

+#include <thread>
+
 namespace advss {

 const std::string MacroConditionRecord::id = "recording";
@@ -10,45 +12,81 @@ bool MacroConditionRecord::_registered = MacroConditionFactory::Register(
 	{MacroConditionRecord::Create, MacroConditionRecordEdit::Create,
 	 "AdvSceneSwitcher.condition.record"});

-const static std::map<RecordState, std::string> recordStates = {
-	{RecordState::STOP, "AdvSceneSwitcher.condition.record.state.stop"},
-	{RecordState::PAUSE, "AdvSceneSwitcher.condition.record.state.pause"},
-	{RecordState::START, "AdvSceneSwitcher.condition.record.state.start"},
+const static std::map<MacroConditionRecord::Condition, std::string>
+	recordStates = {
+		{MacroConditionRecord::Condition::STOP,
+		 "AdvSceneSwitcher.condition.record.state.stop"},
+		{MacroConditionRecord::Condition::PAUSE,
+		 "AdvSceneSwitcher.condition.record.state.pause"},
+		{MacroConditionRecord::Condition::START,
+		 "AdvSceneSwitcher.condition.record.state.start"},
+		{MacroConditionRecord::Condition::DURATION,
+		 "AdvSceneSwitcher.condition.record.state.duration"},
 };

+static bool SetupRecordingTimer();
+static bool recordingTimerIsSetup = SetupRecordingTimer();
+static int currentRecordingDurationInSeconds = 0;
+
 bool MacroConditionRecord::CheckCondition()
 {
-	bool stateMatch = false;
-	switch (_recordState) {
-	case RecordState::STOP:
-		stateMatch = !obs_frontend_recording_active();
-		break;
-	case RecordState::PAUSE:
-		stateMatch = obs_frontend_recording_paused();
-		break;
-	case RecordState::START:
-		stateMatch = obs_frontend_recording_active();
-		break;
+	switch (_condition) {
+	case Condition::STOP:
+		return !obs_frontend_recording_active();
+	case Condition::PAUSE:
+		return obs_frontend_recording_paused();
+	case Condition::START:
+		return obs_frontend_recording_active();
+	case Condition::DURATION:
+		SetTempVarValue(
+			"durationSeconds",
+			std::to_string(currentRecordingDurationInSeconds));
+		return currentRecordingDurationInSeconds > _duration.Seconds();
 	default:
 		break;
 	}
-	return stateMatch;
+	return false;
 }

 bool MacroConditionRecord::Save(obs_data_t *obj) const
 {
 	MacroCondition::Save(obj);
-	obs_data_set_int(obj, "state", static_cast<int>(_recordState));
+	obs_data_set_int(obj, "state", static_cast<int>(_condition));
+	_duration.Save(obj);
 	return true;
 }

 bool MacroConditionRecord::Load(obs_data_t *obj)
 {
 	MacroCondition::Load(obj);
-	_recordState = static_cast<RecordState>(obs_data_get_int(obj, "state"));
+	_condition = static_cast<Condition>(obs_data_get_int(obj, "state"));
+	_duration.Load(obj);
 	return true;
 }

+void MacroConditionRecord::SetCondition(Condition condition)
+{
+	_condition = condition;
+	SetupTempVars();
+}
+
+void MacroConditionRecord::SetupTempVars()
+{
+	MacroCondition::SetupTempVars();
+	switch (_condition) {
+	case Condition::DURATION:
+		AddTempvar(
+			"durationSeconds",
+			obs_module_text(
+				"AdvSceneSwitcher.tempVar.recording.durationSeconds"),
+			obs_module_text(
+				"AdvSceneSwitcher.tempVar.recording.durationSeconds.description"));
+		break;
+	default:
+		break;
+	}
+}
+
 static inline void populateStateSelection(QComboBox *list)
 {
 	for (auto entry : recordStates) {
@@ -58,38 +96,39 @@ static inline void populateStateSelection(QComboBox *list)

 MacroConditionRecordEdit::MacroConditionRecordEdit(
 	QWidget *parent, std::shared_ptr<MacroConditionRecord> entryData)
-	: QWidget(parent)
+	: QWidget(parent),
+	  _condition(new QComboBox(this)),
+	  _duration(new DurationSelection(this))
 {
-	_recordState = new QComboBox();
+	populateStateSelection(_condition);

-	QWidget::connect(_recordState, SIGNAL(currentIndexChanged(int)), this,
-			 SLOT(StateChanged(int)));
-
-	populateStateSelection(_recordState);
-
-	QHBoxLayout *mainLayout = new QHBoxLayout;
-
-	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
-		{"{{recordState}}", _recordState},
-	};
+	QWidget::connect(_condition, SIGNAL(currentIndexChanged(int)), this,
+			 SLOT(ConditionChanged(int)));
+	QWidget::connect(_duration, SIGNAL(DurationChanged(const Duration &)),
+			 this, SLOT(DurationChanged(const Duration &)));

+	auto layout = new QHBoxLayout;
 	PlaceWidgets(obs_module_text("AdvSceneSwitcher.condition.record.entry"),
-		     mainLayout, widgetPlaceholders);
-	setLayout(mainLayout);
+		     layout,
+		     {{"{{condition}}", _condition},
+		      {"{{duration}}", _duration}});
+	setLayout(layout);

 	_entryData = entryData;
 	UpdateEntryData();
 	_loading = false;
 }

-void MacroConditionRecordEdit::StateChanged(int value)
+void MacroConditionRecordEdit::ConditionChanged(int value)
 {
 	if (_loading || !_entryData) {
 		return;
 	}

 	auto lock = LockContext();
-	_entryData->_recordState = static_cast<RecordState>(value);
+	_entryData->SetCondition(
+		static_cast<MacroConditionRecord::Condition>(value));
+	SetWidgetVisibility();
 }

 void MacroConditionRecordEdit::UpdateEntryData()
@@ -98,8 +137,65 @@ void MacroConditionRecordEdit::UpdateEntryData()
 		return;
 	}

-	_recordState->setCurrentIndex(
-		static_cast<int>(_entryData->_recordState));
+	_condition->setCurrentIndex(
+		static_cast<int>(_entryData->GetCondition()));
+	_duration->SetDuration(_entryData->_duration);
+	SetWidgetVisibility();
+}
+
+void MacroConditionRecordEdit::DurationChanged(const Duration &duration)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	auto lock = LockContext();
+	_entryData->_duration = duration;
+}
+
+void MacroConditionRecordEdit::SetWidgetVisibility()
+{
+	_duration->setVisible(_entryData->GetCondition() ==
+			      MacroConditionRecord::Condition::DURATION);
+}
+
+bool SetupRecordingTimer()
+{
+	static std::atomic_bool recordingStopped = {true};
+	static std::atomic_bool recordingPaused = {false};
+	static auto handleRecordingEvents = [](enum obs_frontend_event event,
+					       void *) {
+		switch (event) {
+		case OBS_FRONTEND_EVENT_RECORDING_STOPPED:
+			recordingStopped = true;
+			break;
+		case OBS_FRONTEND_EVENT_RECORDING_STARTED:
+			recordingStopped = false;
+			break;
+		case OBS_FRONTEND_EVENT_RECORDING_PAUSED:
+			recordingPaused = true;
+			break;
+		case OBS_FRONTEND_EVENT_RECORDING_UNPAUSED:
+			recordingPaused = false;
+			break;
+		};
+	};
+	obs_frontend_add_event_callback(handleRecordingEvents, nullptr);
+	std::thread thread([]() {
+		while (true) {
+			std::this_thread::sleep_for(std::chrono::seconds(1));
+			if (recordingStopped) {
+				currentRecordingDurationInSeconds = 0;
+				continue;
+			}
+			if (recordingPaused) {
+				continue;
+			}
+			++currentRecordingDurationInSeconds;
+		}
+	});
+	thread.detach();
+	return true;
 }

 } // namespace advss
--- a/src/macro-core/macro-condition-recording.hpp
+++ b/src/macro-core/macro-condition-recording.hpp
@@ -6,12 +6,6 @@

 namespace advss {

-enum class RecordState {
-	STOP,
-	PAUSE,
-	START,
-};
-
 class MacroConditionRecord : public MacroCondition {
 public:
 	MacroConditionRecord(Macro *m) : MacroCondition(m) {}
@@ -24,9 +18,21 @@ public:
 		return std::make_shared<MacroConditionRecord>(m);
 	}

-	RecordState _recordState = RecordState::STOP;
+	enum class Condition {
+		STOP,
+		PAUSE,
+		START,
+		DURATION,
+	};
+
+	void SetCondition(Condition);
+	Condition GetCondition() const { return _condition; }
+	Duration _duration;

 private:
+	void SetupTempVars();
+
+	Condition _condition = Condition::STOP;
 	static bool _registered;
 	static const std::string id;
 };
@@ -48,13 +54,15 @@ public:
 	}

 private slots:
-	void StateChanged(int value);
-
-protected:
-	QComboBox *_recordState;
-	std::shared_ptr<MacroConditionRecord> _entryData;
+	void ConditionChanged(int value);
+	void DurationChanged(const Duration &);

 private:
+	void SetWidgetVisibility();
+
+	QComboBox *_condition;
+	DurationSelection *_duration;
+	std::shared_ptr<MacroConditionRecord> _entryData;
 	bool _loading = true;
 };

--- a/src/macro-core/macro-condition-websocket.cpp
+++ b/src/macro-core/macro-condition-websocket.cpp
@@ -34,28 +34,24 @@ static bool matchRegex(const RegexConfig &conf, const std::string &msg,

 bool MacroConditionWebsocket::CheckCondition()
 {
-	const std::vector<std::string> *messages = nullptr;
+	std::vector<std::string> messages;
 	switch (_type) {
 	case MacroConditionWebsocket::Type::REQUEST:
-		messages = &switcher->websocketMessages;
+		messages = GetWebsocketMessages();
 		break;
 	case MacroConditionWebsocket::Type::EVENT: {
 		auto connection = _connection.lock();
 		if (!connection) {
 			return false;
 		}
-		messages = &connection->Events();
+		messages = connection->Events();
 		break;
 	}
 	default:
 		break;
 	}

-	if (!messages) {
-		return false;
-	}
-
-	for (const auto &msg : *messages) {
+	for (const auto &msg : messages) {
 		if (_regex.Enabled()) {
 			if (matchRegex(_regex, msg, _message)) {
 				SetVariableValue(msg);
--- a/src/macro-core/macro-condition-window.cpp
+++ b/src/macro-core/macro-condition-window.cpp
@@ -176,6 +176,7 @@ std::string MacroConditionWindow::GetShortDesc() const

 void MacroConditionWindow::SetupTempVars()
 {
+	MacroCondition::SetupTempVars();
 	AddTempvar(
 		"window",
 		obs_module_text("AdvSceneSwitcher.tempVar.window.window"),
--- a/src/macro-core/macro-segment.cpp
+++ b/src/macro-core/macro-segment.cpp
@@ -146,7 +146,6 @@ void MacroSegment::InvalidateTempVarValues()
 std::optional<const TempVariable>
 MacroSegment::GetTempVar(const std::string &id) const
 {
-	TempVariable *result = nullptr;
 	for (auto &var : _tempVariables) {
 		if (var.ID() == id) {
 			return var;
--- a/src/macro-core/macro-tab.cpp
+++ b/src/macro-core/macro-tab.cpp
@@ -235,21 +235,18 @@ void AdvSceneSwitcher::ExportMacros()
 		}
 	}

-	auto data = obs_data_create();
-	auto macroArray = obs_data_array_create();
+	OBSDataAutoRelease data = obs_data_create();
+	OBSDataArrayAutoRelease macroArray = obs_data_array_create();
 	for (const auto &macro : macros) {
-		obs_data_t *obj = obs_data_create();
+		OBSDataAutoRelease obj = obs_data_create();
 		macro->Save(obj);
 		obs_data_array_push_back(macroArray, obj);
-		obs_data_release(obj);
 	}
 	obs_data_set_array(data, "macros", macroArray);
 	switcher->SaveVariables(data);
-	obs_data_array_release(macroArray);
 	obs_data_set_string(data, "version", g_GIT_TAG);
 	auto json = obs_data_get_json(data);
 	QString exportString(json);
-	obs_data_release(data);

 	MacroExportImportDialog::ExportMacros(exportString);
 }
@@ -268,8 +265,9 @@ void AdvSceneSwitcher::SetupMacroSegmentSelection(MacroSection type, int idx)
 		return;
 	}

-	MacroSegmentList *setList, *resetList1, *resetList2;
-	int *setIdx, *resetIdx1, *resetIdx2;
+	MacroSegmentList *setList = nullptr, *resetList1 = nullptr,
+			 *resetList2 = nullptr;
+	int *setIdx = nullptr, *resetIdx1 = nullptr, *resetIdx2 = nullptr;
 	std::deque<std::shared_ptr<MacroSegment>> segements;

 	switch (type) {
@@ -394,7 +392,8 @@ void AdvSceneSwitcher::ImportMacros()
 	if (!MacroExportImportDialog::ImportMacros(json)) {
 		return;
 	}
-	auto data = obs_data_create_from_json(json.toStdString().c_str());
+	OBSDataAutoRelease data =
+		obs_data_create_from_json(json.toStdString().c_str());
 	if (!data) {
 		DisplayMessage(obs_module_text(
 			"AdvSceneSwitcher.macroTab.import.invalid"));
@@ -410,27 +409,26 @@ void AdvSceneSwitcher::ImportMacros()
 		     version);
 	}

-	auto array = obs_data_get_array(data, "macros");
+	OBSDataArrayAutoRelease array = obs_data_get_array(data, "macros");
 	size_t count = obs_data_array_count(array);

 	int groupSize = 0;
 	std::shared_ptr<Macro> group;
+	std::vector<std::shared_ptr<Macro>> importedMacros;

 	auto lock = LockContext();
-
 	for (size_t i = 0; i < count; i++) {
-		obs_data_t *array_obj = obs_data_array_item(array, i);
+		OBSDataAutoRelease array_obj = obs_data_array_item(array, i);
 		auto macro = std::make_shared<Macro>();
 		macro->Load(array_obj);
-		macro->PostLoad();

 		if (macroNameExists(macro->Name()) &&
 		    !ResolveMacroImportNameConflict(macro)) {
-			obs_data_release(array_obj);
 			groupSize--;
 			continue;
 		}

+		importedMacros.emplace_back(macro);
 		switcher->macros.emplace_back(macro);
 		if (groupSize > 0 && !macro->IsGroup()) {
 			Macro::PrepareMoveToGroup(group, macro);
@@ -445,11 +443,11 @@ void AdvSceneSwitcher::ImportMacros()
 			// to the group as they come up.
 			macro->ResetGroupSize();
 		}
-
-		obs_data_release(array_obj);
 	}
-	obs_data_array_release(array);
-	obs_data_release(data);
+
+	for (const auto &macro : importedMacros) {
+		macro->PostLoad();
+	}

 	ui->macros->Reset(switcher->macros,
 			  switcher->macroProperties._highlightExecuted);
@@ -700,8 +698,7 @@ void AdvSceneSwitcher::MacroSelectionAboutToChange()
 	// actions nor elseActions being visible when the condition <-> action
 	// splitter is moved
 	if (elsePos[0] == 0 && elsePos[1] == 0) {
-		macro->SetElseActionSplitterPosition(QList<int>()
-						     << 999999 << 0);
+		maximizeFirstSplitterEntry(ui->macroElseActionSplitter);
 		return;
 	}
 	macro->SetElseActionSplitterPosition(
@@ -790,6 +787,8 @@ bool shouldRestoreSplitter(const QList<int> &pos)

 void AdvSceneSwitcher::SetupMacroTab()
 {
+	ui->macroElseActions->installEventFilter(this);
+
 	if (switcher->macros.size() == 0 && !switcher->disableHints) {
 		addPulse = PulseWidget(ui->macroAdd, QColor(Qt::green));
 	}
@@ -862,6 +861,8 @@ void AdvSceneSwitcher::SetupMacroTab()
 	SetButtonIcon(ui->conditionTop, (pathPrefix + "DoubleUp.svg").c_str());
 	SetButtonIcon(ui->conditionBottom,
 		      (pathPrefix + "DoubleDown.svg").c_str());
+	SetButtonIcon(ui->toggleElseActions,
+		      (pathPrefix + "NotEqual.svg").c_str());

 	// Reserve more space for macro edit area than for the macro list
 	ui->macroListMacroEditSplitter->setStretchFactor(0, 1);
@@ -988,13 +989,12 @@ void AdvSceneSwitcher::CopyMacro()
 		return;
 	}

-	obs_data_t *data = obs_data_create();
+	OBSDataAutoRelease data = obs_data_create();
 	macro->Save(data);
 	newMacro->Load(data);
 	newMacro->PostLoad();
 	newMacro->SetName(name);
 	Macro::PrepareMoveToGroup(macro->Parent(), newMacro);
-	obs_data_release(data);

 	ui->macros->Add(newMacro, macro);
 	ui->macroAdd->disconnect(addPulse);
@@ -1100,6 +1100,31 @@ void AdvSceneSwitcher::MaximizeConditions()
 	MinimizeActions();
 }

+void AdvSceneSwitcher::on_toggleElseActions_clicked()
+{
+	auto elsePosition = ui->macroElseActionSplitter->sizes();
+	if (elsePosition[1] == 0) {
+		centerSplitterPosition(ui->macroElseActionSplitter);
+		return;
+	}
+
+	maximizeFirstSplitterEntry(ui->macroElseActionSplitter);
+}
+
+void AdvSceneSwitcher::SetElseActionsStateToHidden()
+{
+	ui->toggleElseActions->setToolTip(obs_module_text(
+		"AdvSceneSwitcher.macroTab.toggleElseActions.show.tooltip"));
+	ui->toggleElseActions->setChecked(false);
+}
+
+void AdvSceneSwitcher::SetElseActionsStateToVisible()
+{
+	ui->toggleElseActions->setToolTip(obs_module_text(
+		"AdvSceneSwitcher.macroTab.toggleElseActions.hide.tooltip"));
+	ui->toggleElseActions->setChecked(true);
+}
+
 bool AdvSceneSwitcher::MacroTabIsInFocus()
 {
 	return isActiveWindow() && isAncestorOf(focusWidget()) &&
--- a/src/macro-core/macro.cpp
+++ b/src/macro-core/macro.cpp
@@ -149,6 +149,7 @@ bool Macro::CeckMatch()
 			}
 			break;
 		case LogicType::OR_NOT:
+			_matched = _matched || !cond;
 			if (!cond) {
 				c->SetHighlight();
 			}
--- a/src/macro-external/midi/midi-helpers.cpp
+++ b/src/macro-external/midi/midi-helpers.cpp
@@ -1,15 +1,17 @@
 #include "midi-helpers.hpp"

 #include <utility.hpp>
+#include <log-helper.hpp>
 #include <obs-module-helper.hpp>
-#include <switcher-data.hpp>
+#include <plugin-state-helper.hpp>
+#include <sync-helper.hpp>

 namespace advss {

 static std::map<std::pair<MidiDeviceType, int>, MidiDeviceInstance *>
 SetupMidiMessageVector()
 {
-	GetSwitcher()->AddIntervalResetStep(
+	AddIntervalResetStep(
 		MidiDeviceInstance::ClearMessageBuffersOfAllDevices);
 	return {};
 }
--- a/src/macro-external/twitch/chat-connection.cpp
+++ b/src/macro-external/twitch/chat-connection.cpp
@@ -3,7 +3,7 @@
 #include "twitch-helpers.hpp"

 #include <log-helper.hpp>
-#include <switcher-data.hpp>
+#include <plugin-state-helper.hpp>

 namespace advss {

@@ -364,8 +364,7 @@ TwitchChatConnection::~TwitchChatConnection()

 static bool setupChatMessageClear()
 {
-	GetSwitcher()->AddIntervalResetStep(
-		&TwitchChatConnection::ClearAllMessages);
+	AddIntervalResetStep(&TwitchChatConnection::ClearAllMessages);
 	return true;
 }

--- a/src/macro-external/twitch/event-sub.cpp
+++ b/src/macro-external/twitch/event-sub.cpp
@@ -3,7 +3,7 @@
 #include "twitch-helpers.hpp"

 #include <log-helper.hpp>
-#include <switcher-data.hpp>
+#include <plugin-state-helper.hpp>

 namespace advss {

@@ -58,7 +58,7 @@ EventSub::~EventSub()

 static bool setupEventSubMessageClear()
 {
-	GetSwitcher()->AddIntervalResetStep(&EventSub::ClearAllEvents);
+	AddIntervalResetStep(&EventSub::ClearAllEvents);
 	return true;
 }

--- a/src/macro-external/twitch/token.cpp
+++ b/src/macro-external/twitch/token.cpp
@@ -1,13 +1,19 @@
 #include "token.hpp"
 #include "twitch-helpers.hpp"

-#include <switcher-data.hpp>
+#include <plugin-state-helper.hpp>
+#include <log-helper.hpp>
+#include <obs-module-helper.hpp>
 #include <utility.hpp>
 #include <QScrollArea>
 #include <QDesktopServices>
+#include <QGroupBox>
+#include <QUrl>

 namespace advss {

+static const int tokenGrabberPort = 8080;
+
 static std::deque<std::shared_ptr<Item>> twitchTokens;

 const std::unordered_map<std::string, std::string> TokenOption::_apiIdToLocale{
@@ -76,8 +82,8 @@ static void loadConnections(obs_data_t *obj);

 bool setupTwitchTokenSupport()
 {
-	GetSwitcher()->AddSaveStep(saveConnections);
-	GetSwitcher()->AddLoadStep(loadConnections);
+	AddSaveStep(saveConnections);
+	AddLoadStep(loadConnections);
 	return true;
 }

@@ -605,7 +611,7 @@ static std::string generateScopeString(const std::set<TokenOption> &options)

 static std::string getHtml(const QString &redirect)
 {
-	const char *html = R"(
+	QString html = R"(
 	<html>
 	<head>
 	    <title>Advanced scene switcher</title>
@@ -617,17 +623,18 @@ static std::string getHtml(const QString &redirect)
 	        if (document.location.hash && document.location.hash != '') {
 	            var parsedHash = new URLSearchParams(window.location.hash.slice(1));
 	            if (parsedHash.get('access_token')) {
-	                window.location.replace(`http://localhost:8080/token?access_token=${parsedHash.get('access_token')}&state=${parsedHash.get('state')}`);
+	                window.location.replace(`http://localhost:%1/token?access_token=${parsedHash.get('access_token')}&state=${parsedHash.get('state')}`);
 	                output.textContent = 'It is safe to close this window';
 	            }
 	        } else {
-	            window.location.replace('%1');
+	            window.location.replace('%2');
 	        }
 	    </script>
 	</body>
 	</html>)";

-	return QString(html).arg(redirect).toStdString();
+	return html.arg(QString::number(tokenGrabberPort), redirect)
+		.toStdString();
 }

 void TwitchTokenSettingsDialog::RequestToken()
@@ -722,13 +729,16 @@ void TokenGrabberThread::run()

 	// Generate URI to request token
 	auto state = generateStateString();
-	auto getTokenURI = "https://id.twitch.tv/oauth2/authorize"
-			   "?response_type=token"
-			   "&client_id=" +
-			   QString(GetClientID()) +
-			   "&redirect_uri=http://localhost:8080/auth"
-			   "&scope=" +
-			   _scope + "&state=" + QString::fromStdString(state);
+	QString getTokenURI =
+		("https://id.twitch.tv/oauth2/authorize"
+		 "?response_type=token"
+		 "&client_id=" +
+		 QString(GetClientID()) +
+		 "&redirect_uri=http://localhost:%1"
+		 "/auth"
+		 "&scope=" +
+		 _scope + "&state=" + QString::fromStdString(state))
+			.arg(QString::number(tokenGrabberPort));

 	// Setup server receiving token string
 	auto html = getHtml(getTokenURI);
@@ -787,8 +797,19 @@ void TokenGrabberThread::run()

 	// Start the server and wait
 	std::unique_lock<std::mutex> lock(_mutex);
-	_serverThread =
-		std::thread([this]() { _server.listen("localhost", 8080); });
+	_serverThread = std::thread([this]() {
+		if (!_server.bind_to_port("localhost", tokenGrabberPort, 0)) {
+			blog(LOG_WARNING,
+			     "Failed to bind token server to localhost %d!",
+			     tokenGrabberPort);
+			return;
+		}
+		if (!_server.listen_after_bind()) {
+			blog(LOG_WARNING, "Token server failed to listen()!");
+			return;
+		}
+		vblog(LOG_INFO, "Token server stopped!");
+	});
 	auto time = std::chrono::high_resolution_clock::now() +
 		    std::chrono::seconds(_timeout);
 	while (!_stopWaiting) {
--- a/src/macro-external/video/macro-condition-video.cpp
+++ b/src/macro-external/video/macro-condition-video.cpp
@@ -177,8 +177,8 @@ bool MacroConditionVideo::Load(obs_data_t *obj)
 {
 	MacroCondition::Load(obj);
 	_video.Load(obj);
-	_condition =
-		static_cast<VideoCondition>(obs_data_get_int(obj, "condition"));
+	SetCondition(static_cast<VideoCondition>(
+		obs_data_get_int(obj, "condition")));
 	_file = obs_data_get_string(obj, "filePath");
 	_blockUntilScreenshotDone =
 		obs_data_get_bool(obj, "blockUntilScreenshotDone");
@@ -215,8 +215,15 @@ void MacroConditionVideo::GetScreenshot(bool blocking)
 {
 	auto source = obs_weak_source_get_source(_video.GetVideo());
 	_screenshotData.~ScreenshotHelper();
-	new (&_screenshotData)
-		ScreenshotHelper(source, blocking, GetSwitcher()->interval);
+	QRect screenshotArea;
+	if (_areaParameters.enable && _condition != VideoCondition::NO_IMAGE) {
+		screenshotArea.setRect(_areaParameters.area.x,
+				       _areaParameters.area.y,
+				       _areaParameters.area.width,
+				       _areaParameters.area.height);
+	}
+	new (&_screenshotData) ScreenshotHelper(
+		source, screenshotArea, blocking, GetSwitcher()->interval);
 	obs_source_release(source);
 	_getNextScreenshot = false;
 }
@@ -261,6 +268,12 @@ bool MacroConditionVideo::SetLanguage(const std::string &language)
 	return _ocrParameters.SetLanguageCode(language);
 }

+void MacroConditionVideo::SetCondition(VideoCondition condition)
+{
+	_condition = condition;
+	SetupTempVars();
+}
+
 bool MacroConditionVideo::ScreenshotContainsPattern()
 {
 	cv::Mat result;
@@ -269,9 +282,12 @@ bool MacroConditionVideo::ScreenshotContainsPattern()
 		     _patternMatchParameters.useAlphaAsMask,
 		     _patternMatchParameters.matchMode);
 	if (result.total() == 0) {
+		SetTempVarValue("patternCount", "0");
 		return false;
 	}
-	return countNonZero(result) > 0;
+	const auto count = countNonZero(result);
+	SetTempVarValue("patternCount", std::to_string(count));
+	return count > 0;
 }

 bool MacroConditionVideo::OutputChanged()
@@ -300,12 +316,15 @@ bool MacroConditionVideo::ScreenshotContainsObject()
 				   _objMatchParameters.minNeighbors,
 				   _objMatchParameters.minSize.CV(),
 				   _objMatchParameters.maxSize.CV());
-	return objects.size() > 0;
+	const auto count = objects.size();
+	SetTempVarValue("objectCount", std::to_string(count));
+	return count > 0;
 }

 bool MacroConditionVideo::CheckBrightnessThreshold()
 {
 	_currentBrightness = GetAvgBrightness(_screenshotData.image) / 255.;
+	SetTempVarValue("brightness", std::to_string(_currentBrightness));
 	return _currentBrightness > _brightnessThreshold;
 }

@@ -318,6 +337,7 @@ bool MacroConditionVideo::CheckOCR()
 	auto text = RunOCR(_ocrParameters.GetOCR(), _screenshotData.image,
 			   _ocrParameters.color, _ocrParameters.colorThreshold);
 	SetVariableValue(text);
+	SetTempVarValue("text", text);
 	if (!_ocrParameters.regex.Enabled()) {
 		return text == std::string(_ocrParameters.text);
 	}
@@ -332,21 +352,22 @@ bool MacroConditionVideo::CheckOCR()

 bool MacroConditionVideo::CheckColor()
 {
-	return ContainsPixelsInColorRange(_screenshotData.image,
-					  _colorParameters.color,
-					  _colorParameters.colorThreshold,
-					  _colorParameters.matchThreshold);
+	const bool ret = ContainsPixelsInColorRange(
+		_screenshotData.image, _colorParameters.color,
+		_colorParameters.colorThreshold,
+		_colorParameters.matchThreshold);
+	// Way too slow for now
+	//SetTempVarValue("dominantColor", GetDominantColor(_screenshotData.image, 3)
+	//				 .name(QColor::HexArgb)
+	//				 .toStdString());
+	SetTempVarValue("color", GetAverageColor(_screenshotData.image)
+					 .name(QColor::HexArgb)
+					 .toStdString());
+	return ret;
 }

 bool MacroConditionVideo::Compare()
 {
-	if (_areaParameters.enable && _condition != VideoCondition::NO_IMAGE) {
-		_screenshotData.image = _screenshotData.image.copy(
-			_areaParameters.area.x, _areaParameters.area.y,
-			_areaParameters.area.width,
-			_areaParameters.area.height);
-	}
-
 	if (_condition != VideoCondition::OCR) {
 		SetVariableValue("");
 	}
@@ -378,6 +399,58 @@ bool MacroConditionVideo::Compare()
 	return false;
 }

+void MacroConditionVideo::SetupTempVars()
+{
+	MacroCondition::SetupTempVars();
+	switch (_condition) {
+	case VideoCondition::PATTERN:
+		AddTempvar(
+			"patternCount",
+			obs_module_text(
+				"AdvSceneSwitcher.tempVar.video.patternCount"),
+			obs_module_text(
+				"AdvSceneSwitcher.tempVar.video.patternCount.description"));
+		break;
+	case VideoCondition::OBJECT:
+		AddTempvar(
+			"objectCount",
+			obs_module_text(
+				"AdvSceneSwitcher.tempVar.video.objectCount"),
+			obs_module_text(
+				"AdvSceneSwitcher.tempVar.video.objectCount.description"));
+		break;
+	case VideoCondition::BRIGHTNESS:
+		AddTempvar(
+			"brightness",
+			obs_module_text(
+				"AdvSceneSwitcher.tempVar.video.brightness"),
+			obs_module_text(
+				"AdvSceneSwitcher.tempVar.video.brightness.description"));
+		break;
+	case VideoCondition::OCR:
+		AddTempvar(
+			"text",
+			obs_module_text("AdvSceneSwitcher.tempVar.video.text"),
+			obs_module_text(
+				"AdvSceneSwitcher.tempVar.video.text.description"));
+		break;
+	case VideoCondition::COLOR:
+		AddTempvar(
+			"color",
+			obs_module_text("AdvSceneSwitcher.tempVar.video.color"),
+			obs_module_text(
+				"AdvSceneSwitcher.tempVar.video.color.description"));
+		break;
+	case VideoCondition::MATCH:
+	case VideoCondition::DIFFER:
+	case VideoCondition::HAS_NOT_CHANGED:
+	case VideoCondition::HAS_CHANGED:
+	case VideoCondition::NO_IMAGE:
+	default:
+		break;
+	}
+}
+
 static inline void populateVideoInputSelection(QComboBox *list)
 {
 	for (const auto &[_, name] : videoInputTypes) {
@@ -1155,7 +1228,7 @@ void MacroConditionVideoEdit::UpdatePreviewTooltip()
 		return;
 	}

-	if (!requiresFileInput(_entryData->_condition)) {
+	if (!requiresFileInput(_entryData->GetCondition())) {
 		this->setToolTip("");
 		return;
 	}
@@ -1224,7 +1297,7 @@ void MacroConditionVideoEdit::ConditionChanged(int cond)
 	}

 	auto lock = LockContext();
-	_entryData->_condition = static_cast<VideoCondition>(cond);
+	_entryData->SetCondition(static_cast<VideoCondition>(cond));
 	_entryData->ResetLastMatch();
 	SetWidgetVisibility();

@@ -1239,7 +1312,7 @@ void MacroConditionVideoEdit::ConditionChanged(int cond)
 	_previewDialog.PatternMatchParametersChanged(
 		_entryData->_patternMatchParameters);

-	if (_entryData->_condition == VideoCondition::OBJECT) {
+	if (_entryData->GetCondition() == VideoCondition::OBJECT) {
 		auto path = _entryData->GetModelDataPath();
 		_entryData->_objMatchParameters.cascade =
 			initObjectCascade(path);
@@ -1482,27 +1555,28 @@ void MacroConditionVideoEdit::SetWidgetVisibility()
 	_sources->setVisible(_entryData->_video.type ==
 			     VideoInput::Type::SOURCE);
 	_scenes->setVisible(_entryData->_video.type == VideoInput::Type::SCENE);
-	_imagePath->setVisible(requiresFileInput(_entryData->_condition));
+	_imagePath->setVisible(requiresFileInput(_entryData->GetCondition()));
 	_usePatternForChangedCheck->setVisible(
-		patternControlIsOptional(_entryData->_condition));
-	_patternThreshold->setVisible(needsThreshold(_entryData->_condition));
-	_useAlphaAsMask->setVisible(_entryData->_condition ==
+		patternControlIsOptional(_entryData->GetCondition()));
+	_patternThreshold->setVisible(
+		needsThreshold(_entryData->GetCondition()));
+	_useAlphaAsMask->setVisible(_entryData->GetCondition() ==
 				    VideoCondition::PATTERN);
 	SetLayoutVisible(_patternMatchModeLayout,
-			 _entryData->_condition == VideoCondition::PATTERN);
-	_brightness->setVisible(_entryData->_condition ==
+			 _entryData->GetCondition() == VideoCondition::PATTERN);
+	_brightness->setVisible(_entryData->GetCondition() ==
 				VideoCondition::BRIGHTNESS);
-	_showMatch->setVisible(needsShowMatch(_entryData->_condition));
-	_ocr->setVisible(_entryData->_condition == VideoCondition::OCR);
-	_objectDetect->setVisible(_entryData->_condition ==
+	_showMatch->setVisible(needsShowMatch(_entryData->GetCondition()));
+	_ocr->setVisible(_entryData->GetCondition() == VideoCondition::OCR);
+	_objectDetect->setVisible(_entryData->GetCondition() ==
 				  VideoCondition::OBJECT);
-	_color->setVisible(_entryData->_condition == VideoCondition::COLOR);
+	_color->setVisible(_entryData->GetCondition() == VideoCondition::COLOR);
 	SetLayoutVisible(_throttleControlLayout,
-			 needsThrottleControls(_entryData->_condition));
-	_area->setVisible(needsAreaControls(_entryData->_condition));
+			 needsThrottleControls(_entryData->GetCondition()));
+	_area->setVisible(needsAreaControls(_entryData->GetCondition()));

-	if (_entryData->_condition == VideoCondition::HAS_CHANGED ||
-	    _entryData->_condition == VideoCondition::HAS_NOT_CHANGED) {
+	if (_entryData->GetCondition() == VideoCondition::HAS_CHANGED ||
+	    _entryData->GetCondition() == VideoCondition::HAS_NOT_CHANGED) {
 		_patternThreshold->setVisible(
 			_entryData->_patternMatchParameters.useForChangedCheck);
 		SetLayoutVisible(
@@ -1528,7 +1602,7 @@ void MacroConditionVideoEdit::SetupPreviewDialogParams()
 	_previewDialog.VideoSelectionChanged(_entryData->_video);
 	_previewDialog.AreaParametersChanged(_entryData->_areaParameters);
 	_previewDialog.ConditionChanged(
-		static_cast<int>(_entryData->_condition));
+		static_cast<int>(_entryData->GetCondition()));
 }

 void MacroConditionVideoEdit::UpdateEntryData()
@@ -1541,7 +1615,8 @@ void MacroConditionVideoEdit::UpdateEntryData()
 		static_cast<int>(_entryData->_video.type));
 	_scenes->SetScene(_entryData->_video.scene);
 	_sources->SetSource(_entryData->_video.source);
-	_condition->setCurrentIndex(static_cast<int>(_entryData->_condition));
+	_condition->setCurrentIndex(
+		static_cast<int>(_entryData->GetCondition()));
 	_reduceLatency->setChecked(_entryData->_blockUntilScreenshotDone);
 	_imagePath->SetPath(QString::fromStdString(_entryData->_file));
 	_usePatternForChangedCheck->setChecked(
--- a/src/macro-external/video/macro-condition-video.hpp
+++ b/src/macro-external/video/macro-condition-video.hpp
@@ -45,8 +45,10 @@ public:
 	void SetPageSegMode(tesseract::PageSegMode);
 	bool SetLanguage(const std::string &);

+	void SetCondition(VideoCondition);
+	VideoCondition GetCondition() const { return _condition; }
+
 	VideoInput _video;
-	VideoCondition _condition = VideoCondition::MATCH;
 	std::string _file = obs_module_text("AdvSceneSwitcher.enterPath");
 	// Enabling this will reduce matching latency, but slow down the
 	// the condition checks of all macros overall.
@@ -74,6 +76,10 @@ private:
 	bool Compare();
 	bool CheckShouldBeSkipped();

+	void SetupTempVars();
+
+	VideoCondition _condition = VideoCondition::MATCH;
+
 	bool _getNextScreenshot = true;
 	ScreenshotHelper _screenshotData;
 	QImage _matchImage;
--- a/src/macro-external/video/opencv-helpers.cpp
+++ b/src/macro-external/video/opencv-helpers.cpp
@@ -225,6 +225,61 @@ bool ContainsPixelsInColorRange(const QImage &image, const QColor &color,
 	return matchPercentage >= totalPixelMatchThreshold;
 }

+QColor GetAverageColor(const QImage &img)
+{
+	if (img.isNull()) {
+		return QColor();
+	}
+
+	auto image = QImageToMat(img);
+	cv::Scalar meanColor = cv::mean(image);
+	int averageBlue = cvRound(meanColor[0]);
+	int averageGreen = cvRound(meanColor[1]);
+	int averageRed = cvRound(meanColor[2]);
+
+	return QColor(averageRed, averageGreen, averageBlue);
+}
+
+QColor GetDominantColor(const QImage &img, int k)
+{
+	if (img.isNull()) {
+		return QColor();
+	}
+
+	auto image = QImageToMat(img);
+	cv::Mat reshapedImage = image.reshape(1, image.rows * image.cols);
+	reshapedImage.convertTo(reshapedImage, CV_32F);
+
+	cv::mean(reshapedImage);
+
+	// Apply k-means clustering to group similar colors
+	cv::TermCriteria criteria(
+		cv::TermCriteria::EPS + cv::TermCriteria::MAX_ITER, 100, 0.2);
+	cv::Mat labels, centers;
+	cv::kmeans(reshapedImage, k, labels, criteria, 1,
+		   cv::KMEANS_RANDOM_CENTERS, centers);
+
+	// Find the dominant color
+	// Center of the cluster with the largest number of pixels
+	cv::Mat counts = cv::Mat::zeros(1, k, CV_32SC1);
+	for (int i = 0; i < labels.rows; i++) {
+		counts.at<int>(0, labels.at<int>(i))++;
+	}
+
+	cv::Point max_loc;
+	cv::minMaxLoc(counts, nullptr, nullptr, nullptr, &max_loc);
+	try {
+		cv::Scalar dominantColor = centers.at<cv::Scalar>(max_loc.y);
+		const int blue = cv::saturate_cast<int>(dominantColor.val[0]);
+		const int green = cv::saturate_cast<int>(dominantColor.val[1]);
+		const int red = cv::saturate_cast<int>(dominantColor.val[2]);
+		const int alpha = cv::saturate_cast<int>(dominantColor.val[3]);
+		return QColor(red, green, blue, alpha);
+	} catch (...) {
+	}
+	return QColor();
+}
+
 // Assumption is that QImage uses Format_RGBA8888.
 // Conversion from: https://github.com/dbzhang800/QtOpenCV
 cv::Mat QImageToMat(const QImage &img)
--- a/src/macro-external/video/opencv-helpers.hpp
+++ b/src/macro-external/video/opencv-helpers.hpp
@@ -66,6 +66,8 @@ std::string RunOCR(tesseract::TessBaseAPI *, const QImage &, const QColor &,
 bool ContainsPixelsInColorRange(const QImage &image, const QColor &color,
 				double colorDeviationThreshold,
 				double totalPixelMatchThreshold);
+QColor GetAverageColor(const QImage &img);
+QColor GetDominantColor(const QImage &image, int k);
 cv::Mat QImageToMat(const QImage &img);
 QImage MatToQImage(const cv::Mat &mat);

--- a/src/macro-external/video/preview-dialog.cpp
+++ b/src/macro-external/video/preview-dialog.cpp
@@ -255,7 +255,13 @@ void PreviewImage::CreateImage(const VideoInput &video, PreviewType type,
 			       VideoCondition condition)
 {
 	auto source = obs_weak_source_get_source(video.GetVideo());
-	ScreenshotHelper screenshot(source, true);
+	QRect screenshotArea;
+	if (areaParams.enable && type == PreviewType::SHOW_MATCH) {
+		screenshotArea.setRect(areaParams.area.x, areaParams.area.y,
+				       areaParams.area.width,
+				       areaParams.area.height);
+	}
+	ScreenshotHelper screenshot(source, screenshotArea, true);
 	obs_source_release(source);

 	if (!video.ValidSelection() || !screenshot.done) {
@@ -274,11 +280,6 @@ void PreviewImage::CreateImage(const VideoInput &video, PreviewType type,

 	if (type == PreviewType::SHOW_MATCH) {
 		std::unique_lock<std::mutex> lock(_mtx);
-		if (areaParams.enable) {
-			screenshot.image = screenshot.image.copy(
-				areaParams.area.x, areaParams.area.y,
-				areaParams.area.width, areaParams.area.height);
-		}
 		// Will emit status label update
 		MarkMatch(screenshot.image, patternMatchParams,
 			  patternImageData, objDetectParams, ocrParams,
--- a/src/switcher-data.cpp
+++ b/src/switcher-data.cpp
@@ -45,7 +45,7 @@ void SwitcherData::Prune()
 	}

 	if (nonMatchingScene && !WeakSourceValid(nonMatchingScene)) {
-		switchIfNotMatching = NoMatch::NO_SWITCH;
+		switchIfNotMatching = NoMatchBehavior::NO_SWITCH;
 		nonMatchingScene = nullptr;
 	}

--- a/src/switcher-data.hpp
+++ b/src/switcher-data.hpp
@@ -21,6 +21,7 @@
 #include "curl-helper.hpp"
 #include "priority-helper.hpp"
 #include "log-helper.hpp"
+#include "plugin-state-helper.hpp"

 #include <condition_variable>
 #include <vector>
@@ -80,7 +81,6 @@ public:

 	void SaveSettings(obs_data_t *obj);
 	void SaveMacros(obs_data_t *obj);
-	void SaveConnections(obs_data_t *obj);
 	void SaveVariables(obs_data_t *obj);
 	void SaveGeneralSettings(obs_data_t *obj);
 	void SaveHotkeys(obs_data_t *obj);
@@ -89,7 +89,6 @@ public:

 	void LoadSettings(obs_data_t *obj);
 	void LoadMacros(obs_data_t *obj);
-	void LoadConnections(obs_data_t *obj);
 	void LoadVariables(obs_data_t *obj);
 	void LoadGeneralSettings(obs_data_t *obj);
 	void LoadHotkeys(obs_data_t *obj);
@@ -143,8 +142,7 @@ public:

 	int interval = default_interval;
 	OBSWeakSource nonMatchingScene;
-	enum class NoMatch { NO_SWITCH = 0, SWITCH = 1, RANDOM_SWITCH = 2 };
-	NoMatch switchIfNotMatching = NoMatch::NO_SWITCH;
+	NoMatchBehavior switchIfNotMatching = NoMatchBehavior::NO_SWITCH;
 	Duration noMatchDelay;
 	enum class StartupBehavior { PERSIST = 0, START = 1, STOP = 2 };
 	StartupBehavior startupBehavior = StartupBehavior::PERSIST;
@@ -175,8 +173,6 @@ public:
 	bool macroSceneSwitched = false;

 	Curlhelper curl;
-	std::deque<std::shared_ptr<Item>> connections;
-	std::vector<std::string> websocketMessages;
 	std::deque<std::shared_ptr<Item>> variables;

 	std::string lastTitle;
--- a/src/utils/connection-manager.cpp
+++ b/src/utils/connection-manager.cpp
@@ -1,18 +1,33 @@
 #include "connection-manager.hpp"
 #include "utility.hpp"
+#include "obs-module-helper.hpp"
+#include "plugin-state-helper.hpp"
 #include "name-dialog.hpp"
-#include "switcher-data.hpp"

 #include <algorithm>
 #include <QAction>
 #include <QMenu>
-#include <obs-module.h>

 Q_DECLARE_METATYPE(advss::Connection *);

 namespace advss {

-void SwitcherData::SaveConnections(obs_data_t *obj)
+static std::deque<std::shared_ptr<Item>> connections;
+static void saveConnections(obs_data_t *obj);
+static void loadConnections(obs_data_t *obj);
+
+void SetupConnectionManager()
+{
+	static bool done = false;
+	if (done) {
+		return;
+	}
+	AddSaveStep(saveConnections);
+	AddLoadStep(loadConnections);
+	done = true;
+}
+
+static void saveConnections(obs_data_t *obj)
 {
 	obs_data_array_t *connectionArray = obs_data_array_create();
 	for (const auto &c : connections) {
@@ -25,7 +40,7 @@ void SwitcherData::SaveConnections(obs_data_t *obj)
 	obs_data_array_release(connectionArray);
 }

-void SwitcherData::LoadConnections(obs_data_t *obj)
+static void loadConnections(obs_data_t *obj)
 {
 	connections.clear();

@@ -192,7 +207,7 @@ Connection *GetConnectionByName(const QString &name)

 Connection *GetConnectionByName(const std::string &name)
 {
-	for (auto &con : switcher->connections) {
+	for (auto &con : connections) {
 		if (con->Name() == name) {
 			return dynamic_cast<Connection *>(con.get());
 		}
@@ -202,7 +217,7 @@ Connection *GetConnectionByName(const std::string &name)

 std::weak_ptr<Connection> GetWeakConnectionByName(const std::string &name)
 {
-	for (const auto &c : switcher->connections) {
+	for (const auto &c : connections) {
 		if (c->Name() == name) {
 			std::weak_ptr<Connection> wp =
 				std::dynamic_pointer_cast<Connection>(c);
@@ -226,6 +241,11 @@ std::string GetWeakConnectionName(std::weak_ptr<Connection> connection)
 	return con->Name();
 }

+std::deque<std::shared_ptr<Item>> &GetConnections()
+{
+	return connections;
+}
+
 static bool ConnectionNameAvailable(const QString &name)
 {
 	return !GetConnectionByName(name);
@@ -244,8 +264,7 @@ static bool AskForSettingsWrapper(QWidget *parent, Item &settings)
 }

 ConnectionSelection::ConnectionSelection(QWidget *parent)
-	: ItemSelection(switcher->connections, Connection::Create,
-			AskForSettingsWrapper,
+	: ItemSelection(connections, Connection::Create, AskForSettingsWrapper,
 			"AdvSceneSwitcher.connection.select",
 			"AdvSceneSwitcher.connection.add",
 			"AdvSceneSwitcher.item.nameNotAvailable",
@@ -296,7 +315,7 @@ void ConnectionSelection::SetConnection(

 ConnectionSettingsDialog::ConnectionSettingsDialog(QWidget *parent,
 						   const Connection &settings)
-	: ItemSettingsDialog(settings, switcher->connections,
+	: ItemSettingsDialog(settings, connections,
 			     "AdvSceneSwitcher.connection.select",
 			     "AdvSceneSwitcher.connection.add",
 			     "AdvSceneSwitcher.item.nameNotAvailable", parent),
--- a/src/utils/connection-manager.hpp
+++ b/src/utils/connection-manager.hpp
@@ -1,5 +1,6 @@
 #pragma once
 #include "item-selection-helpers.hpp"
+#include "websocket-helpers.hpp"

 #include <QComboBox>
 #include <QPushButton>
@@ -14,10 +15,11 @@
 #include <QGridLayout>
 #include <deque>
 #include <obs.hpp>
-#include <websocket-helpers.hpp>

 namespace advss {

+void SetupConnectionManager();
+
 class ConnectionSelection;
 class ConnectionSettingsDialog;

@@ -69,6 +71,7 @@ Connection *GetConnectionByName(const std::string &);
 std::weak_ptr<Connection> GetWeakConnectionByName(const std::string &name);
 std::weak_ptr<Connection> GetWeakConnectionByQString(const QString &name);
 std::string GetWeakConnectionName(std::weak_ptr<Connection>);
+std::deque<std::shared_ptr<Item>> &GetConnections();

 class ConnectionSettingsDialog : public ItemSettingsDialog {
 	Q_OBJECT
--- a/src/utils/curl-helper.cpp
+++ b/src/utils/curl-helper.cpp
@@ -50,6 +50,15 @@ CURLcode Curlhelper::Perform()
 	return _perform(_curl);
 }

+char *Curlhelper::GetError(CURLcode code)
+{
+	if (!_initialized) {
+		return (char *)"CURL initialization failed";
+	}
+
+	return _error(code);
+}
+
 bool Curlhelper::LoadLib()
 {
 	_lib = new QLibrary(curl_library_name, nullptr);
@@ -101,8 +110,10 @@ bool Curlhelper::Resolve()
 	_slistAppend = (slistAppendFunction)_lib->resolve("curl_slist_append");
 	_perform = (performFunction)_lib->resolve("curl_easy_perform");
 	_cleanup = (cleanupFunction)_lib->resolve("curl_easy_cleanup");
+	_error = (errorFunction)_lib->resolve("curl_easy_strerror");

-	if (_init && _setopt && _slistAppend && _perform && _cleanup) {
+	if (_init && _setopt && _slistAppend && _perform && _cleanup &&
+	    _error) {
 		blog(LOG_INFO, "[adv-ss] curl loaded successfully");
 		return true;
 	}
--- a/src/utils/curl-helper.hpp
+++ b/src/utils/curl-helper.hpp
@@ -5,22 +5,25 @@
 namespace advss {

 typedef CURL *(*initFunction)(void);
-typedef void (*cleanupFunction)(CURL *);
 typedef CURLcode (*setOptFunction)(CURL *, CURLoption, ...);
 typedef struct curl_slist *(*slistAppendFunction)(struct curl_slist *list,
 						  const char *string);
 typedef CURLcode (*performFunction)(CURL *);
+typedef void (*cleanupFunction)(CURL *);
+typedef char *(*errorFunction)(CURLcode);

 class Curlhelper {
 public:
 	Curlhelper();
 	~Curlhelper();

+	bool Initialized() { return _initialized; }
+
 	template<typename... Args> CURLcode SetOpt(CURLoption, Args...);
 	struct curl_slist *SlistAppend(struct curl_slist *list,
 				       const char *string);
 	CURLcode Perform();
-	bool Initialized() { return _initialized; }
+	char *GetError(CURLcode code);

 private:
 	bool LoadLib();
@@ -31,6 +34,7 @@ private:
 	slistAppendFunction _slistAppend = nullptr;
 	performFunction _perform = nullptr;
 	cleanupFunction _cleanup = nullptr;
+	errorFunction _error = nullptr;
 	CURL *_curl = nullptr;
 	QLibrary *_lib;
 	bool _initialized = false;
--- a/src/utils/duration-control.cpp
+++ b/src/utils/duration-control.cpp
@@ -1,168 +1,12 @@
 #include "duration-control.hpp"
 #include "mouse-wheel-guard.hpp"
-#include "obs-module.h"
+#include "obs-module-helper.hpp"
 #include "utility.hpp"

-#include <sstream>
-#include <iomanip>
 #include <QHBoxLayout>

 namespace advss {

-Duration::Duration(double initialValueInSeconds) : _value(initialValueInSeconds)
-{
-}
-
-void Duration::Save(obs_data_t *obj, const char *name) const
-{
-	auto data = obs_data_create();
-	_value.Save(data, "value");
-	obs_data_set_int(data, "unit", static_cast<int>(_unit));
-	obs_data_set_int(data, "version", 1);
-	obs_data_set_obj(obj, name, data);
-	obs_data_release(data);
-}
-
-static int durationUnitToMultiplier(Duration::Unit u)
-{
-	switch (u) {
-	case Duration::Unit::SECONDS:
-		return 1;
-	case Duration::Unit::MINUTES:
-		return 60;
-	case Duration::Unit::HOURS:
-		return 3600;
-	default:
-		break;
-	}
-
-	return 0;
-}
-
-void Duration::Load(obs_data_t *obj, const char *name)
-{
-	auto data = obs_data_get_obj(obj, name);
-
-	// TODO: remove this fallback
-	if (!data || !obs_data_has_user_value(data, "version") ||
-	    obs_data_get_int(data, "version") != 1) {
-		bool usingDefaultArgs = strcmp("duration", name) == 0;
-		if (usingDefaultArgs) {
-			_value = obs_data_get_double(obj, "seconds");
-		}
-		if (_value.GetValue() == 0.0) {
-			_value = obs_data_get_double(obj, name);
-		}
-
-		if (usingDefaultArgs) {
-			_unit = static_cast<Duration::Unit>(
-				obs_data_get_int(obj, "displayUnit"));
-		} else if (_value.GetValue() >= 86400) {
-			_unit = (_value.GetValue() / 60 >= 86400)
-					? Duration::Unit::HOURS
-					: Duration::Unit::MINUTES;
-		} else {
-			_unit = Duration::Unit::SECONDS;
-		}
-
-		_value = _value / durationUnitToMultiplier(_unit);
-
-		obs_data_release(data);
-		return;
-	}
-
-	_value.Load(data, "value");
-	_unit = static_cast<Duration::Unit>(obs_data_get_int(data, "unit"));
-	obs_data_release(data);
-}
-
-bool Duration::DurationReached()
-{
-	if (IsReset()) {
-		_startTime = std::chrono::high_resolution_clock::now();
-	}
-
-	auto runTime = std::chrono::duration_cast<std::chrono::milliseconds>(
-		std::chrono::high_resolution_clock::now() - _startTime);
-	return runTime.count() >= Milliseconds();
-}
-
-bool Duration::IsReset() const
-{
-	return _startTime.time_since_epoch().count() == 0;
-}
-
-double Duration::Seconds() const
-{
-	return _value.GetValue() * durationUnitToMultiplier(_unit);
-}
-
-double Duration::Milliseconds() const
-{
-	return Seconds() * 1000.0;
-}
-
-double Duration::TimeRemaining() const
-{
-	if (IsReset()) {
-		return Seconds();
-	}
-	auto runTime = std::chrono::duration_cast<std::chrono::milliseconds>(
-		std::chrono::high_resolution_clock::now() - _startTime);
-
-	if (runTime.count() >= Milliseconds()) {
-		return 0;
-	}
-	return (Milliseconds() - runTime.count()) / 1000.0;
-}
-
-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 = {};
-}
-
-static std::string durationUnitToString(Duration::Unit u)
-{
-	switch (u) {
-	case Duration::Unit::SECONDS:
-		return obs_module_text("AdvSceneSwitcher.unit.secends");
-	case Duration::Unit::MINUTES:
-		return obs_module_text("AdvSceneSwitcher.unit.minutes");
-	case Duration::Unit::HOURS:
-		return obs_module_text("AdvSceneSwitcher.unit.hours");
-	default:
-		break;
-	}
-
-	return "";
-}
-
-std::string Duration::ToString() const
-{
-	std::ostringstream ss;
-	ss << std::fixed << std::setprecision(2) << _value.GetValue() << " "
-	   << durationUnitToString(_unit);
-	if (!_value.IsFixedType()) {
-		ss << " [" << GetWeakVariableName(_value.GetVariable()) << "]";
-	}
-	return ss.str();
-}
-
-void Duration::SetUnit(Unit u)
-{
-	double prevMultiplier = durationUnitToMultiplier(_unit);
-	double newMultiplier = durationUnitToMultiplier(u);
-	_unit = u;
-	_value = _value * (prevMultiplier / newMultiplier);
-}
-
 static void populateUnits(QComboBox *list)
 {
 	list->addItem(obs_module_text("AdvSceneSwitcher.unit.secends"));
@@ -214,13 +58,28 @@ void DurationSelection::_DurationChanged(const NumberVariable<double> &value)
 	emit DurationChanged(_current);
 }

+static int durationUnitToMultiplier(Duration::Unit u)
+{
+	switch (u) {
+	case Duration::Unit::SECONDS:
+		return 1;
+	case Duration::Unit::MINUTES:
+		return 60;
+	case Duration::Unit::HOURS:
+		return 3600;
+	default:
+		break;
+	}
+
+	return 0;
+}
+
 void DurationSelection::_UnitChanged(int idx)
 {
 	Duration::Unit unit = static_cast<Duration::Unit>(idx);
 	double prevMultiplier = durationUnitToMultiplier(_current._unit);
 	double newMultiplier = durationUnitToMultiplier(unit);
 	_current._unit = unit;
-	const QSignalBlocker b(_duration);
 	_duration->SetFixedValue(_duration->Value() *
 				 (prevMultiplier / newMultiplier));
 	emit DurationChanged(_current);
--- a/src/utils/duration-control.hpp
+++ b/src/utils/duration-control.hpp
@@ -1,48 +1,14 @@
 #pragma once
+#include "duration.hpp"
 #include "variable-spinbox.hpp"
-#include "obs-data.h"

 #include <QWidget>
 #include <QDoubleSpinBox>
 #include <QComboBox>
 #include <QPushButton>
-#include <chrono>

 namespace advss {

-class Duration {
-public:
-	Duration() = default;
-	Duration(double initialValueInSeconds);
-
-	void Save(obs_data_t *obj, const char *name = "duration") const;
-	void Load(obs_data_t *obj, const char *name = "duration");
-
-	bool DurationReached();
-	bool IsReset() const;
-	double Seconds() const;
-	double Milliseconds() const;
-	double TimeRemaining() const;
-	void SetTimeRemaining(double);
-	void Reset();
-	std::string ToString() const;
-
-	enum class Unit {
-		SECONDS,
-		MINUTES,
-		HOURS,
-	};
-	Unit GetUnit() const { return _unit; }
-	void SetUnit(Unit u);
-
-private:
-	NumberVariable<double> _value = 0.;
-	Unit _unit = Unit::SECONDS;
-	std::chrono::high_resolution_clock::time_point _startTime;
-
-	friend class DurationSelection;
-};
-
 class DurationSelection : public QWidget {
 	Q_OBJECT
 public:
--- a/src/utils/duration.cpp
+++ b/src/utils/duration.cpp
@@ -0,0 +1,169 @@
+#include "duration.hpp"
+#include "obs-module-helper.hpp"
+#include "utility.hpp"
+
+#include <sstream>
+#include <iomanip>
+
+namespace advss {
+
+Duration::Duration(double initialValueInSeconds) : _value(initialValueInSeconds)
+{
+}
+
+void Duration::Save(obs_data_t *obj, const char *name) const
+{
+	auto data = obs_data_create();
+	_value.Save(data, "value");
+	obs_data_set_int(data, "unit", static_cast<int>(_unit));
+	obs_data_set_int(data, "version", 1);
+	obs_data_set_obj(obj, name, data);
+	obs_data_release(data);
+}
+
+static int durationUnitToMultiplier(Duration::Unit u);
+
+void Duration::Load(obs_data_t *obj, const char *name)
+{
+	auto data = obs_data_get_obj(obj, name);
+
+	// TODO: remove this fallback
+	if (!data || !obs_data_has_user_value(data, "version") ||
+	    obs_data_get_int(data, "version") != 1) {
+		bool usingDefaultArgs = strcmp("duration", name) == 0;
+		if (usingDefaultArgs) {
+			_value = obs_data_get_double(obj, "seconds");
+		}
+		if (_value.GetValue() == 0.0) {
+			_value = obs_data_get_double(obj, name);
+		}
+
+		if (usingDefaultArgs) {
+			_unit = static_cast<Duration::Unit>(
+				obs_data_get_int(obj, "displayUnit"));
+		} else if (_value.GetValue() >= 86400) {
+			_unit = (_value.GetValue() / 60 >= 86400)
+					? Duration::Unit::HOURS
+					: Duration::Unit::MINUTES;
+		} else {
+			_unit = Duration::Unit::SECONDS;
+		}
+
+		_value = _value / durationUnitToMultiplier(_unit);
+
+		obs_data_release(data);
+		return;
+	}
+
+	_value.Load(data, "value");
+	_unit = static_cast<Duration::Unit>(obs_data_get_int(data, "unit"));
+	obs_data_release(data);
+}
+
+bool Duration::DurationReached()
+{
+	if (IsReset()) {
+		_startTime = std::chrono::high_resolution_clock::now();
+	}
+
+	auto runTime = std::chrono::duration_cast<std::chrono::milliseconds>(
+		std::chrono::high_resolution_clock::now() - _startTime);
+	return runTime.count() >= Milliseconds();
+}
+
+bool Duration::IsReset() const
+{
+	return _startTime.time_since_epoch().count() == 0;
+}
+
+double Duration::Seconds() const
+{
+	return _value.GetValue() * durationUnitToMultiplier(_unit);
+}
+
+double Duration::Milliseconds() const
+{
+	return Seconds() * 1000.0;
+}
+
+double Duration::TimeRemaining() const
+{
+	if (IsReset()) {
+		return Seconds();
+	}
+	auto runTime = std::chrono::duration_cast<std::chrono::milliseconds>(
+		std::chrono::high_resolution_clock::now() - _startTime);
+
+	if (runTime.count() >= Milliseconds()) {
+		return 0;
+	}
+	return (Milliseconds() - runTime.count()) / 1000.0;
+}
+
+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 = {};
+}
+
+static std::string durationUnitToString(Duration::Unit u)
+{
+	switch (u) {
+	case Duration::Unit::SECONDS:
+		return obs_module_text("AdvSceneSwitcher.unit.secends");
+	case Duration::Unit::MINUTES:
+		return obs_module_text("AdvSceneSwitcher.unit.minutes");
+	case Duration::Unit::HOURS:
+		return obs_module_text("AdvSceneSwitcher.unit.hours");
+	default:
+		break;
+	}
+
+	return "";
+}
+
+std::string Duration::ToString() const
+{
+	std::ostringstream ss;
+	ss << std::fixed << std::setprecision(2) << _value.GetValue() << " "
+	   << durationUnitToString(_unit);
+	if (!_value.IsFixedType()) {
+		ss << " [" << GetWeakVariableName(_value.GetVariable()) << "]";
+	}
+	return ss.str();
+}
+
+// TODO: Remove the code below
+// Only used for backwards compatibility
+
+static int durationUnitToMultiplier(Duration::Unit u)
+{
+	switch (u) {
+	case Duration::Unit::SECONDS:
+		return 1;
+	case Duration::Unit::MINUTES:
+		return 60;
+	case Duration::Unit::HOURS:
+		return 3600;
+	default:
+		break;
+	}
+
+	return 0;
+}
+
+void Duration::SetUnit(Unit u)
+{
+	double prevMultiplier = durationUnitToMultiplier(_unit);
+	double newMultiplier = durationUnitToMultiplier(u);
+	_unit = u;
+	_value = _value * (prevMultiplier / newMultiplier);
+}
+
+} // namespace advss
--- a/src/utils/duration.hpp
+++ b/src/utils/duration.hpp
@@ -0,0 +1,45 @@
+#pragma once
+#include "variable-number.hpp"
+#include "obs-data.h"
+
+#include <chrono>
+
+namespace advss {
+
+class Duration {
+public:
+	Duration() = default;
+	Duration(double initialValueInSeconds);
+
+	void Save(obs_data_t *obj, const char *name = "duration") const;
+	void Load(obs_data_t *obj, const char *name = "duration");
+
+	bool DurationReached();
+	bool IsReset() const;
+	double Seconds() const;
+	double Milliseconds() const;
+	double TimeRemaining() const;
+	void SetTimeRemaining(double);
+	void Reset();
+	std::string ToString() const;
+
+	enum class Unit {
+		SECONDS,
+		MINUTES,
+		HOURS,
+	};
+	Unit GetUnit() const { return _unit; }
+
+	// TODO: Remove
+	// Only use this function if you intend to convert old settings formats
+	void SetUnit(Unit u);
+
+private:
+	NumberVariable<double> _value = 0.;
+	Unit _unit = Unit::SECONDS;
+	std::chrono::high_resolution_clock::time_point _startTime;
+
+	friend class DurationSelection;
+};
+
+} // namespace advss
--- a/src/utils/macro-run-button.cpp
+++ b/src/utils/macro-run-button.cpp
@@ -10,19 +10,26 @@ namespace advss {

 MacroRunButton::MacroRunButton(QWidget *parent) : QPushButton(parent)
 {
-	if (window()) {
-		window()->installEventFilter(this);
+	installEventFilter(this);
+	auto parentWindow = window();
+	if (parentWindow) {
+		parentWindow->installEventFilter(this);
 	}
+
+	setToolTip(obs_module_text("AdvSceneSwitcher.macroTab.run.tooltip"));
+
 	QWidget::connect(this, SIGNAL(pressed()), this, SLOT(Pressed()));
 }

 void MacroRunButton::SetMacroTree(MacroTree *macros)
 {
 	_macros = macros;
+
 	QWidget::connect(macros, SIGNAL(MacroSelectionChanged()), this,
 			 SLOT(MacroSelectionChanged()));
 	QWidget::connect(&_timer, &QTimer::timeout, this,
 			 [this]() { MacroSelectionChanged(); });
+
 	_timer.start(1000);
 }

@@ -33,35 +40,53 @@ void MacroRunButton::MacroSelectionChanged()
 		_macroHasElseActions = false;
 		return;
 	}
+
 	_macroHasElseActions = macro->ElseActions().size() > 0;
 }

 bool MacroRunButton::eventFilter(QObject *obj, QEvent *event)
 {
 	if (!_macroHasElseActions) {
-		setText(obs_module_text("AdvSceneSwitcher.macroTab.run"));
-		_runElseActionsKeyHeld = false;
+		DeactivateElseState();
 		return QPushButton::eventFilter(obj, event);
 	}

-	if (event->type() == QEvent::KeyPress) {
+	auto eventType = event->type();
+	if (eventType == QEvent::KeyPress) {
 		QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
-		if (keyEvent->key() == Qt::Key_Control) {
-			setText(obs_module_text(
-				"AdvSceneSwitcher.macroTab.runElse"));
-			_runElseActionsKeyHeld = true;
+		if (keyEvent->key() == Qt::Key_Shift) {
+			if (underMouse()) {
+				ActivateElseState();
+			}
+			_shiftHeld = true;
 		}
-	} else if (event->type() == QEvent::KeyRelease) {
+	} else if (eventType == QEvent::KeyRelease) {
 		QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
-		if (keyEvent->key() == Qt::Key_Control) {
-			setText(obs_module_text(
-				"AdvSceneSwitcher.macroTab.run"));
-			_runElseActionsKeyHeld = false;
+		if (keyEvent->key() == Qt::Key_Shift) {
+			DeactivateElseState();
+			_shiftHeld = false;
 		}
+	} else if (_shiftHeld && obj == this && eventType == QEvent::Enter) {
+		ActivateElseState();
+	} else if (obj == this && eventType == QEvent::Leave) {
+		DeactivateElseState();
 	}
+
 	return QPushButton::eventFilter(obj, event);
 }

+void MacroRunButton::ActivateElseState()
+{
+	setText(obs_module_text("AdvSceneSwitcher.macroTab.runElse"));
+	_elseStateActive = true;
+}
+
+void MacroRunButton::DeactivateElseState()
+{
+	setText(obs_module_text("AdvSceneSwitcher.macroTab.run"));
+	_elseStateActive = false;
+}
+
 void MacroRunButton::Pressed()
 {
 	auto macro = _macros->GetCurrentMacro();
@@ -69,9 +94,9 @@ void MacroRunButton::Pressed()
 		return;
 	}

-	bool ret = _runElseActionsKeyHeld
-			   ? macro->PerformActions(false, true, true)
-			   : macro->PerformActions(true, true, true);
+	bool ret = _elseStateActive ? macro->PerformActions(false, true, true)
+				    : macro->PerformActions(true, true, true);
+
 	if (!ret) {
 		QString err =
 			obs_module_text("AdvSceneSwitcher.macroTab.runFail");
--- a/src/utils/macro-run-button.hpp
+++ b/src/utils/macro-run-button.hpp
@@ -20,9 +20,13 @@ private slots:
 	void Pressed();

 private:
-	MacroTree *_macros = nullptr;
+	void ActivateElseState();
+	void DeactivateElseState();
+
 	bool _macroHasElseActions = false;
-	bool _runElseActionsKeyHeld = false;
+	bool _elseStateActive = false;
+	bool _shiftHeld = false;
+	MacroTree *_macros = nullptr;
 	QTimer _timer;
 };

--- a/src/utils/math-helpers.cpp
+++ b/src/utils/math-helpers.cpp
@@ -1,32 +1,35 @@
 #include "math-helpers.hpp"
+#include "obs-module-helper.hpp"
+
 #include <exprtk.hpp>
-
-#ifdef UNIT_TEST
-const char *obs_module_text(const char *text)
-{
-	return text;
-}
-#else
-#include <obs-module.h>
-#endif
-
-typedef exprtk::expression<double> expression_t;
-typedef exprtk::parser<double> parser_t;
+#include <random>

 namespace advss {

 std::variant<double, std::string> EvalMathExpression(const std::string &expr)
 {
-	expression_t expression;
+	static bool setupDone = false;
+	static exprtk::symbol_table<double> symbolTable;
+	static std::random_device rd;
+	static std::mt19937 gen(rd());
+	static std::uniform_real_distribution<double> dis(0.0, 1.0);
+	static auto randomFunc = []() { return dis(gen); };

-	parser_t parser;
+	if (!setupDone) {
+		symbolTable.add_function("random", randomFunc);
+		setupDone = true;
+	}
+
+	exprtk::expression<double> expression;
+	expression.register_symbol_table(symbolTable);
+	exprtk::parser<double> parser;

 	if (parser.compile(expr, expression)) {
 		return expression.value();
 	}
 	return std::string(obs_module_text(
 		       "AdvSceneSwitcher.math.expressionFail")) +
-	       " \"" + expr;
+	       " \"" + expr + "\"";
 }

 bool IsValidNumber(const std::string &str)
--- a/src/utils/obs-module-helper.cpp
+++ b/src/utils/obs-module-helper.cpp
@@ -1,6 +1,9 @@
 #include "obs-module-helper.hpp"
+#ifndef UNIT_TEST
 #include "switcher-data.hpp"
+#endif

+#ifndef UNIT_TEST
 const char *obs_module_text(const char *text)
 {
 	if (!advss::switcher) {
@@ -16,3 +19,15 @@ obs_module_t *obs_current_module()
 	}
 	return advss::switcher->GetModule();
 }
+
+#else
+
+const char *obs_module_text(const char *text)
+{
+	return text;
+};
+obs_module_t *obs_current_module()
+{
+	return nullptr;
+}
+#endif
--- a/src/utils/obs-module-helper.hpp
+++ b/src/utils/obs-module-helper.hpp
@@ -1,5 +1,9 @@
 #pragma once
+#ifndef UNIT_TEST
 #include <obs-module.h>
+#else
+typedef struct obs_module obs_module_t;
+#endif

 const char *obs_module_text(const char *text);
 obs_module_t *obs_current_module();
--- a/src/utils/plugin-state-helper.cpp
+++ b/src/utils/plugin-state-helper.cpp
@@ -0,0 +1,61 @@
+#include "plugin-state-helper.hpp"
+#include "switcher-data.hpp"
+
+namespace advss {
+
+void LoadPluginSettings(obs_data_t *obj)
+{
+	GetSwitcher()->LoadSettings(obj);
+}
+
+void AddSaveStep(std::function<void(obs_data_t *)> step)
+{
+	GetSwitcher()->AddSaveStep(step);
+}
+
+void AddLoadStep(std::function<void(obs_data_t *)> step)
+{
+	GetSwitcher()->AddLoadStep(step);
+}
+
+void AddPostLoadStep(std::function<void()> step)
+{
+	GetSwitcher()->AddPostLoadStep(step);
+}
+
+void AddIntervalResetStep(std::function<void()> step)
+{
+	GetSwitcher()->AddIntervalResetStep(step);
+}
+
+void StopPlugin()
+{
+	GetSwitcher()->Stop();
+}
+
+void StartPlugin()
+{
+	GetSwitcher()->Start();
+}
+
+void SetPluginNoMatchBehavior(NoMatchBehavior behavior)
+{
+	GetSwitcher()->switchIfNotMatching = behavior;
+}
+
+void SetNoMatchScene(const OBSWeakSource &scene)
+{
+	GetSwitcher()->nonMatchingScene = scene;
+}
+
+NoMatchBehavior GetPluginNoMatchBehavior()
+{
+	return GetSwitcher()->switchIfNotMatching;
+}
+
+bool SettingsWindowIsOpened()
+{
+	return GetSwitcher()->settingsWindowOpened;
+}
+
+} // namespace advss
--- a/src/utils/plugin-state-helper.hpp
+++ b/src/utils/plugin-state-helper.hpp
@@ -0,0 +1,24 @@
+#pragma once
+#include <functional>
+#include <obs.hpp>
+
+namespace advss {
+
+void LoadPluginSettings(obs_data_t *);
+
+void AddSaveStep(std::function<void(obs_data_t *)>);
+void AddLoadStep(std::function<void(obs_data_t *)>);
+void AddPostLoadStep(std::function<void()>);
+void AddIntervalResetStep(std::function<void()>);
+
+void StopPlugin();
+void StartPlugin();
+
+enum class NoMatchBehavior { NO_SWITCH = 0, SWITCH = 1, RANDOM_SWITCH = 2 };
+void SetPluginNoMatchBehavior(NoMatchBehavior);
+NoMatchBehavior GetPluginNoMatchBehavior();
+void SetNoMatchScene(const OBSWeakSource &);
+
+bool SettingsWindowIsOpened();
+
+} // namespace advss
--- a/src/utils/screenshot-helper.cpp
+++ b/src/utils/screenshot-helper.cpp
@@ -7,10 +7,11 @@ namespace advss {

 static void ScreenshotTick(void *param, float);

-ScreenshotHelper::ScreenshotHelper(obs_source_t *source, bool blocking,
-				   int timeout, bool saveToFile,
+ScreenshotHelper::ScreenshotHelper(obs_source_t *source, const QRect &subarea,
+				   bool blocking, int timeout, bool saveToFile,
 				   std::string path)
 	: weakSource(OBSGetWeakRef(source)),
+	  _subarea(subarea),
 	  _blocking(blocking),
 	  _saveToFile(saveToFile),
 	  _path(path)
@@ -62,7 +63,12 @@ void ScreenshotHelper::Screenshot()
 		cy = ovi.base_height;
 	}

-	if (!cx || !cy) {
+	QRect renderArea(0, 0, cx, cy);
+	if (!_subarea.isEmpty()) {
+		renderArea &= _subarea;
+	}
+
+	if (renderArea.isEmpty()) {
 		vblog(LOG_WARNING,
 		      "Cannot screenshot \"%s\", invalid target size",
 		      obs_source_get_name(source));
@@ -71,16 +77,24 @@ void ScreenshotHelper::Screenshot()
 		return;
 	}

+	cx = renderArea.width();
+	cy = renderArea.height();
+
 	texrender = gs_texrender_create(GS_RGBA, GS_ZS_NONE);
-	stagesurf = gs_stagesurface_create(cx, cy, GS_RGBA);
+	stagesurf = gs_stagesurface_create(renderArea.width(),
+					   renderArea.height(), GS_RGBA);

 	gs_texrender_reset(texrender);
-	if (gs_texrender_begin(texrender, cx, cy)) {
+	if (gs_texrender_begin(texrender, renderArea.width(),
+			       renderArea.height())) {
 		vec4 zero;
 		vec4_zero(&zero);

 		gs_clear(GS_CLEAR_COLOR, &zero, 0.0f, 0);
-		gs_ortho(0.0f, (float)cx, 0.0f, (float)cy, -100.0f, 100.0f);
+		gs_ortho((float)(renderArea.left()),
+			 (float)(renderArea.right() + 1),
+			 (float)(renderArea.top()),
+			 (float)(renderArea.bottom() + 1), -100.0f, 100.0f);

 		gs_blend_state_push();
 		gs_blend_function(GS_BLEND_ONE, GS_BLEND_ZERO);
--- a/src/utils/screenshot-helper.hpp
+++ b/src/utils/screenshot-helper.hpp
@@ -12,9 +12,9 @@ namespace advss {
 class ScreenshotHelper {
 public:
 	ScreenshotHelper() = default;
-	ScreenshotHelper(obs_source_t *source, bool blocking = false,
-			 int timeout = 1000, bool saveToFile = false,
-			 std::string path = "");
+	ScreenshotHelper(obs_source_t *source, const QRect &subarea = QRect(),
+			 bool blocking = false, int timeout = 1000,
+			 bool saveToFile = false, std::string path = "");
 	ScreenshotHelper &operator=(const ScreenshotHelper &) = delete;
 	ScreenshotHelper(const ScreenshotHelper &) = delete;
 	~ScreenshotHelper();
@@ -39,6 +39,7 @@ public:

 private:
 	std::atomic_bool _initDone = false;
+	QRect _subarea = QRect();
 	bool _blocking = false;
 	std::thread _saveThread;
 	bool _saveToFile = false;
--- a/src/utils/source-setting.cpp
+++ b/src/utils/source-setting.cpp
@@ -50,11 +50,17 @@ std::vector<SourceSetting> GetSoruceSettings(obs_source_t *source)
 		if (!it) {
 			continue;
 		}
-		SourceSetting setting(
-			obs_property_name(it), obs_property_description(it),
-			obs_property_long_description(it)
-				? obs_property_long_description(it)
-				: "");
+		auto name = obs_property_name(it);
+		if (!name) {
+			continue;
+		}
+		auto description = obs_property_description(it);
+		if (!description) {
+			continue;
+		}
+		auto longDescription = obs_property_long_description(it);
+		SourceSetting setting(name, description,
+				      longDescription ? longDescription : "");
 		settings.emplace_back(setting);
 	} while (obs_property_next(&it));
 	obs_properties_destroy(properties);
--- a/src/utils/temp-variable.cpp
+++ b/src/utils/temp-variable.cpp
@@ -2,7 +2,7 @@
 #include "advanced-scene-switcher.hpp"
 #include "macro.hpp"
 #include "macro-segment.hpp"
-#include "switcher-data.hpp"
+#include "plugin-state-helper.hpp"
 #include "utility.hpp"

 #include <QVariant>
@@ -170,7 +170,7 @@ void TempVariableRef::Load(obs_data_t *obj, Macro *macro, const char *name)
 	_id = obs_data_get_string(data, "id");
 	const auto type =
 		static_cast<SegmentType>(obs_data_get_int(data, "type"));
-	switcher->AddPostLoadStep([this, idx, type, macro]() {
+	AddPostLoadStep([this, idx, type, macro]() {
 		this->PostLoad(idx, type, macro);
 	});
 }
@@ -427,7 +427,7 @@ void NotifyUIAboutTempVarChange()
 	obs_queue_task(
 		OBS_TASK_UI,
 		[](void *) {
-			if (!GetSwitcher()->settingsWindowOpened) {
+			if (!SettingsWindowIsOpened()) {
 				return;
 			}
 			AdvSceneSwitcher::window->SegmentTempVarsChanged();
--- a/src/utils/websocket-helpers.cpp
+++ b/src/utils/websocket-helpers.cpp
@@ -1,6 +1,8 @@
 #include "websocket-helpers.hpp"
 #include "connection-manager.hpp"
-#include "switcher-data.hpp"
+#include "log-helper.hpp"
+#include "plugin-state-helper.hpp"
+#include "sync-helper.hpp"

 #include <QCryptographicHash>
 #include <obs-websocket-api.h>
@@ -13,16 +15,38 @@ using websocketpp::lib::bind;

 #define RPC_VERSION 1

+constexpr char VendorName[] = "AdvancedSceneSwitcher";
+constexpr char VendorRequest[] = "AdvancedSceneSwitcherMessage";
+constexpr char VendorEvent[] = "AdvancedSceneSwitcherEvent";
 obs_websocket_vendor vendor;

-void ClearWebsocketMessages()
+static void clearWebsocketMessages();
+static std::vector<std::string> websocketMessages;
+
+void SetupWebsocketHelpers()
 {
-	switcher->websocketMessages.clear();
-	for (auto &connection : switcher->connections) {
-		Connection *c = dynamic_cast<Connection *>(connection.get());
-		if (c) {
-			c->Events().clear();
+	static bool done = false;
+	if (done) {
+		return;
+	}
+	AddIntervalResetStep(clearWebsocketMessages);
+	done = true;
+}
+
+std::vector<std::string> &GetWebsocketMessages()
+{
+	return websocketMessages;
+}
+
+static void clearWebsocketMessages()
+{
+	websocketMessages.clear();
+	for (auto &connection : GetConnections()) {
+		auto c = dynamic_cast<Connection *>(connection.get());
+		if (!c) {
+			continue;
 		}
+		c->Events().clear();
 	}
 }

@@ -44,8 +68,8 @@ static void receiveWebsocketMessage(obs_data_t *request_data, obs_data_t *,
 	}

 	auto msg = obs_data_get_string(request_data, "message");
-	std::lock_guard<std::mutex> lock(switcher->m);
-	switcher->websocketMessages.emplace_back(msg);
+	auto lock = LockContext();
+	websocketMessages.emplace_back(msg);
 	vblog(LOG_INFO, "received message: %s", msg);
 }

@@ -294,7 +318,7 @@ void WSConnection::HandleEvent(obs_data_t *msg)
 		return;
 	}
 	auto eventDataNested = obs_data_get_obj(eventData, "eventData");
-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	_messages.emplace_back(obs_data_get_string(eventDataNested, "message"));
 	vblog(LOG_INFO, "received event msg \"%s\"",
 	      obs_data_get_string(eventDataNested, "message"));
@@ -326,7 +350,7 @@ void WSConnection::OnGenericMessage(connection_hdl, client::message_ptr message)
 		return;
 	}

-	std::lock_guard<std::mutex> lock(switcher->m);
+	auto lock = LockContext();
 	const auto payload = message->get_payload();
 	_messages.emplace_back(payload);
 	vblog(LOG_INFO, "received event msg \"%s\"", payload.c_str());
--- a/src/utils/websocket-helpers.hpp
+++ b/src/utils/websocket-helpers.hpp
@@ -21,18 +21,17 @@
 namespace advss {

 using websocketpp::connection_hdl;
-typedef websocketpp::server<websocketpp::config::asio> server;
-typedef websocketpp::client<websocketpp::config::asio_client> client;

-constexpr char VendorName[] = "AdvancedSceneSwitcher";
-constexpr char VendorRequest[] = "AdvancedSceneSwitcherMessage";
-constexpr char VendorEvent[] = "AdvancedSceneSwitcherEvent";
+void SetupWebsocketHelpers();

-void ClearWebsocketMessages();
 void SendWebsocketEvent(const std::string &);
 std::string ConstructVendorRequestMessage(const std::string &message);
+std::vector<std::string> &GetWebsocketMessages();

 class WSConnection : public QObject {
+	using server = websocketpp::server<websocketpp::config::asio>;
+	using client = websocketpp::client<websocketpp::config::asio_client>;
+
 public:
 	explicit WSConnection(bool useOBSProtocol = true);
 	virtual ~WSConnection();
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -5,13 +5,17 @@ get_target_property(ADVSS_SOURCE_DIR advanced-scene-switcher-lib SOURCE_DIR)
 add_executable(${PROJECT_NAME})
 target_compile_definitions(${PROJECT_NAME} PRIVATE UNIT_TEST)
 target_compile_features(${PROJECT_NAME} PRIVATE cxx_std_17)
-target_sources(${PROJECT_NAME}
-               PRIVATE tests.cpp ${ADVSS_SOURCE_DIR}/src/utils/math-helpers.cpp)
+
+target_sources(
+  ${PROJECT_NAME}
+  PRIVATE tests.cpp ${ADVSS_SOURCE_DIR}/src/utils/math-helpers.cpp
+          ${ADVSS_SOURCE_DIR}/src/utils/obs-module-helper.cpp)
 target_include_directories(
  ${PROJECT_NAME}
  PRIVATE "${ADVSS_SOURCE_DIR}/src" "${ADVSS_SOURCE_DIR}/src/legacy"
          "${ADVSS_SOURCE_DIR}/src/macro-core" "${ADVSS_SOURCE_DIR}/src/utils"
          "${ADVSS_SOURCE_DIR}/forms" "${ADVSS_SOURCE_DIR}/deps/exprtk")
+
 if(MSVC)
  target_compile_options(${PROJECT_NAME} PUBLIC /MP /d2FH4- /wd4267 /wd4267
                                                /bigobj)
Author	SHA1	Message	Date
WarmUpTill	267855fded	Cleanup * Use OBSSourceAutoRelease * Do not return true if source selection is invalid	2023-12-17 10:40:29 +01:00
WarmUpTill	4bdebb7feb	Fix crash when asking for settings backup This dialog cannot be modal since other plugins might attempt to display content which might result in a deadlock.	2023-12-16 19:02:38 +01:00
Michael Kirsch	ab5f69d2ef	Decrease the minimal interval time to 10ms	2023-12-13 19:29:14 +01:00
Michael Kirsch	63ee36ddfe	Enable Area Selection in ScreenshotHelper class	2023-12-13 14:19:17 +01:00
WarmUpTill	43967f5ded	Add temp variable support for video condition	2023-12-10 14:26:30 +01:00
WarmUpTill	c043053b2b	Remove unused variable	2023-12-10 14:26:30 +01:00
WarmUpTill	220f27bd0a	Move plugin dependencies to Aptfile	2023-12-10 13:42:39 +01:00
WarmUpTill	83914d5378	Linux: resolve procps symbols at runtime This is done to be able to support both libprocps and libproc2. Either of them or neither might be available on all platforms and this should not prevent the plugin from being used at all.	2023-12-10 13:42:39 +01:00
WarmUpTill	57e4b1a3f1	Fix warning	2023-12-10 13:42:39 +01:00
WarmUpTill	c85e556924	Add support for "random()" expression Generates a random number between [0,1)	2023-12-10 13:33:18 +01:00
WarmUpTill	8c0be8011d	Enable use of obs-module-helper.hpp in tests	2023-12-10 13:33:18 +01:00
WarmUpTill	7914f75876	Fix macro references not being resolved when importing macros	2023-12-09 09:52:12 +01:00
WarmUpTill	7d1253e14e	Use RAII wrappers for OBS data	2023-12-09 09:52:12 +01:00
WarmUpTill	d7c58b3eb3	Remove websocket dependency to switcher-data internals	2023-12-09 09:52:12 +01:00
WarmUpTill	fb664b6f08	Reduce dependencies to switcher-data.hpp implementation details This is necessary for the switch to libremidi version 4 due to incompatabilities with websocketpp, but also might save some headaches later on.	2023-12-09 09:52:12 +01:00
WarmUpTill	258a6d076e	Fix "or not" logic type check being ignored	2023-12-09 09:52:12 +01:00
WarmUpTill	32ab060153	Ease configuration of token grabber port	2023-12-09 09:52:12 +01:00
WarmUpTill	91d3784f9b	Don't wait for transition to complete if already on target scene	2023-12-09 09:52:12 +01:00
WarmUpTill	8a5aac3d31	Add option to check the recording duration	2023-12-09 09:52:12 +01:00
WarmUpTill	06c6effb7d	Fix duration value not being updated correctly when changing units	2023-12-09 09:52:12 +01:00
WarmUpTill	f3789c05bd	Move Duration and DurationSelection into separate files	2023-12-09 09:52:12 +01:00
WarmUpTill	c64e1f5e51	Rework Process condition * Add option to en-/disable regex matching * Add tempvar support for process name	2023-12-09 09:52:12 +01:00
WarmUpTill	5d8e24c19a	Add temp variable support to Macro condition	2023-12-09 09:52:12 +01:00
WarmUpTill	f756de05c3	Add option to check if macro is paused	2023-12-09 09:52:12 +01:00
WarmUpTill	574fdb496f	Add error logs for token grabber server	2023-12-09 09:52:12 +01:00
WarmUpTill	5580da69eb	Fix window condition not clearing tempvars of previous condition type	2023-12-09 09:52:12 +01:00
WarmUpTill	35274863c9	Use available layout stretch space for settings input field	2023-12-09 09:52:12 +01:00
Przemek Pawlas	1f31b81f0d	Add else actions toggle button	2023-12-09 09:42:10 +01:00
WarmUpTill	cde111ddeb	Ignore settings which don't have a description or name This fixes a crash when attempting to populate the setttings selection of a Window Capture or Game Capture source	2023-12-07 07:04:50 +01:00
Przemek Pawlas	845c12c01c	Add tooltip for run button explaining else (#931 ) * Add tooltip for run button explaining else * Switch run button modifier to Shift * Toggle button label only when hovering over it	2023-12-06 10:40:14 +01:00
Przemek Pawlas	99a0118d31	Add clipboard text/image copy actions	2023-11-27 21:07:38 +01:00