Refactor, fixes and maximized option for title tab (#40)

* move definitions of switcher structs to separate files

* remove useless comment

* cleanup and silence warnings

* add generic switch

* removed delay on main thread startup as it served no purpose

* clean up ultility.hpp

* do not save switchStr to file as it could cause issues when scenes are renamed

* rename sceneRoundTrip to sceneSequence

* add option to switch if window is maximized to title tab

src/headers/advanced-scene-switcher.hpp

@@ -37,7 +37,7 @@ public:
 	int PauseScenesFindByData(const QString &scene);
 	int PauseWindowsFindByData(const QString &window);
 	int IgnoreWindowsFindByData(const QString &window);
-	int SceneRoundTripFindByData(const QString &scene1);
+	int SceneSequenceFindByData(const QString &scene1);
 	int SceneTransitionsFindByData(const QString &scene1,
 				       const QString &scene2);
 	int DefaultTransitionsFindByData(const QString &scene);
@@ -106,14 +106,14 @@ public slots:
 	void on_ignoreWindowsAdd_clicked();
 	void on_ignoreWindowsRemove_clicked();
 
-	void on_sceneRoundTrips_currentRowChanged(int idx);
-	void on_sceneRoundTripAdd_clicked();
-	void on_sceneRoundTripRemove_clicked();
-	void on_sceneRoundTripSave_clicked();
-	void on_sceneRoundTripLoad_clicked();
-	void on_sceneRoundTripUp_clicked();
-	void on_sceneRoundTripDown_clicked();
-	void on_sceneRoundTripDelayUnits_currentIndexChanged(int index);
+	void on_sceneSequences_currentRowChanged(int idx);
+	void on_sceneSequenceAdd_clicked();
+	void on_sceneSequenceRemove_clicked();
+	void on_sceneSequenceSave_clicked();
+	void on_sceneSequenceLoad_clicked();
+	void on_sceneSequenceUp_clicked();
+	void on_sceneSequenceDown_clicked();
+	void on_sceneSequenceDelayUnits_currentIndexChanged(int index);
 
 	void on_autoStopSceneCheckBox_stateChanged(int state);
 	void on_autoStopScenes_currentTextChanged(const QString &text);
@@ -205,6 +205,7 @@ void GetWindowList(std::vector<std::string> &windows);
 void GetWindowList(QStringList &windows); // Overloaded
 void GetCurrentWindowTitle(std::string &title);
 bool isFullscreen(std::string &title);
+bool isMaximized(std::string &title);
 
 /********************************************************************************
  * Screenregion helper

src/headers/curl-helper.hpp

@@ -3,11 +3,11 @@
 #include <QLibrary>
 
 #if defined(WIN32)
-#define CURL_LIBRARY_NAME "libcurl.dll"
+constexpr auto curl_library_name = "libcurl.dll";
 #elif __APPLE__
-#define CURL_LIBRARY_NAME "libcurl.4.dylib"
+#define curl_library_name "libcurl.4.dylib"
 #else
-#define CURL_LIBRARY_NAME "libcurl.so.4"
+#define curl_library_name "libcurl.so.4"
 #endif
 
 typedef CURL *(*initFunction)(void);

src/headers/switch-audio.hpp

@@ -0,0 +1,115 @@
+#pragma once
+#include <string>
+#include "utility.hpp"
+#include "switch-generic.hpp"
+
+constexpr auto audio_func = 8;
+constexpr auto default_priority_8 = audio_func;
+
+struct AudioSwitch : virtual SceneSwitcherEntry {
+	OBSWeakSource audioSource;
+	int volumeThreshold;
+	float peak;
+	std::string audioSwitchStr;
+	obs_volmeter_t *volmeter;
+
+	const char *getType() { return "audio"; }
+
+	static void setVolumeLevel(void *data,
+				   const float magnitude[MAX_AUDIO_CHANNELS],
+				   const float peak[MAX_AUDIO_CHANNELS],
+				   const float inputPeak[MAX_AUDIO_CHANNELS])
+	{
+		UNUSED_PARAMETER(magnitude);
+		UNUSED_PARAMETER(inputPeak);
+		AudioSwitch *s = static_cast<AudioSwitch *>(data);
+
+		s->peak = peak[0];
+		for (int i = 1; i < MAX_AUDIO_CHANNELS; i++)
+			if (peak[i] > s->peak)
+				s->peak = peak[i];
+	}
+
+	bool valid()
+	{
+		return (usePreviousScene || WeakSourceValid(scene)) &&
+		       WeakSourceValid(audioSource) &&
+		       WeakSourceValid(transition);
+	}
+
+	inline AudioSwitch(OBSWeakSource scene_, OBSWeakSource transition_,
+			   OBSWeakSource audioSource_, int volumeThreshold_,
+			   bool usePreviousScene_, std::string audioSwitchStr_)
+		: SceneSwitcherEntry(scene_, transition_, usePreviousScene_),
+		  audioSource(audioSource_),
+		  volumeThreshold(volumeThreshold_),
+		  audioSwitchStr(audioSwitchStr_)
+	{
+		volmeter = obs_volmeter_create(OBS_FADER_LOG);
+		obs_volmeter_add_callback(volmeter, setVolumeLevel, this);
+		obs_source_t *as = obs_weak_source_get_source(audioSource);
+		if (!obs_volmeter_attach_source(volmeter, as)) {
+			const char *name = obs_source_get_name(as);
+			blog(LOG_WARNING,
+			     "failed to attach volmeter to source %s", name);
+		}
+		obs_source_release(as);
+	}
+
+	AudioSwitch(const AudioSwitch &other)
+		: SceneSwitcherEntry(other.scene, other.transition,
+				     other.usePreviousScene),
+		  audioSource(other.audioSource),
+		  volumeThreshold(other.volumeThreshold),
+		  audioSwitchStr(other.audioSwitchStr)
+	{
+		volmeter = obs_volmeter_create(OBS_FADER_LOG);
+		obs_volmeter_add_callback(volmeter, setVolumeLevel, this);
+		obs_source_t *as =
+			obs_weak_source_get_source(other.audioSource);
+		if (!obs_volmeter_attach_source(volmeter, as)) {
+			const char *name = obs_source_get_name(as);
+			blog(LOG_WARNING,
+			     "failed to attach volmeter to source %s", name);
+		}
+		obs_source_release(as);
+	}
+
+	AudioSwitch(AudioSwitch &&other)
+		: SceneSwitcherEntry(other.scene, other.transition,
+				     other.usePreviousScene),
+		  audioSource(other.audioSource),
+		  volumeThreshold(other.volumeThreshold),
+		  audioSwitchStr(other.audioSwitchStr),
+		  volmeter(other.volmeter)
+	{
+		other.volmeter = nullptr;
+	}
+
+	inline ~AudioSwitch()
+	{
+		obs_volmeter_remove_callback(volmeter, setVolumeLevel, this);
+		obs_volmeter_destroy(volmeter);
+	}
+
+	AudioSwitch &operator=(const AudioSwitch &other)
+	{
+		return *this = AudioSwitch(other);
+	}
+
+	AudioSwitch &operator=(AudioSwitch &&other) noexcept
+	{
+		if (this == &other) {
+			return *this;
+		}
+		obs_volmeter_destroy(volmeter);
+		volmeter = other.volmeter;
+		other.volmeter = nullptr;
+		return *this;
+	}
+};
+
+static inline QString MakeAudioSwitchName(const QString &scene,
+					  const QString &transition,
+					  const QString &audioSrouce,
+					  const int &volume);

src/headers/switch-executable.hpp

@@ -0,0 +1,28 @@
+#pragma once
+#include <string>
+#include "utility.hpp"
+#include "switch-generic.hpp"
+
+constexpr auto exe_func = 3;
+constexpr auto default_priority_3 = exe_func;
+
+struct ExecutableSceneSwitch : SceneSwitcherEntry {
+	QString exe;
+	bool inFocus;
+
+	const char *getType() { return "exec"; }
+
+	inline ExecutableSceneSwitch(OBSWeakSource scene_,
+				     OBSWeakSource transition_,
+				     const QString &exe_, bool inFocus_)
+		: SceneSwitcherEntry(scene_, transition_),
+		  exe(exe_),
+		  inFocus(inFocus_)
+	{
+	}
+};
+
+static inline QString MakeSwitchNameExecutable(const QString &scene,
+					       const QString &value,
+					       const QString &transition,
+					       bool inFocus);

src/headers/switch-file.hpp

@@ -0,0 +1,44 @@
+#pragma once
+#include <string>
+#include "utility.hpp"
+#include "switch-generic.hpp"
+
+constexpr auto read_file_func = 0;
+constexpr auto default_priority_0 = read_file_func;
+
+struct FileSwitch : SceneSwitcherEntry {
+	std::string file;
+	std::string text;
+	bool remote = false;
+	bool useRegex = false;
+	bool useTime = false;
+	QDateTime lastMod;
+
+	const char *getType() { return "file"; }
+
+	inline FileSwitch(OBSWeakSource scene_, OBSWeakSource transition_,
+			  const char *file_, const char *text_, bool remote_,
+			  bool useRegex_, bool useTime_)
+		: SceneSwitcherEntry(scene_, transition_),
+		  file(file_),
+		  text(text_),
+		  remote(remote_),
+		  useRegex(useRegex_),
+		  useTime(useTime_),
+		  lastMod()
+	{
+	}
+};
+
+struct FileIOData {
+	bool readEnabled = false;
+	std::string readPath;
+	bool writeEnabled = false;
+	std::string writePath;
+};
+
+static inline QString MakeFileSwitchName(const QString &scene,
+					 const QString &transition,
+					 const QString &fileName,
+					 const QString &text, bool useRegex,
+					 bool useTime);

src/headers/switch-generic.hpp

@@ -0,0 +1,48 @@
+#pragma once
+#include <string>
+#include <obs.hpp>
+
+struct SceneSwitcherEntry {
+	OBSWeakSource scene;
+	OBSWeakSource transition;
+	bool usePreviousScene;
+
+	virtual bool valid()
+	{
+		return (usePreviousScene || WeakSourceValid(scene)) &&
+		       WeakSourceValid(transition);
+	}
+
+	virtual const char *getType() = 0;
+
+	// TODO
+	//virtual bool checkMatch() = 0;
+
+	virtual void logMatch()
+	{
+		obs_source_t *s = obs_weak_source_get_source(scene);
+		const char *sceneName = obs_source_get_name(s);
+		obs_source_release(s);
+		blog(LOG_INFO,
+		     "Advanced Scene Switcher match for '%s' - switch to scene '%s'",
+		     getType(), sceneName);
+	}
+
+	inline SceneSwitcherEntry() : usePreviousScene(false) {}
+
+	inline SceneSwitcherEntry(OBSWeakSource scene_,
+				  OBSWeakSource transition_,
+				  bool usePreviousScene_)
+		: scene(scene_),
+		  transition(transition_),
+		  usePreviousScene(usePreviousScene_)
+	{
+	}
+	inline SceneSwitcherEntry(OBSWeakSource scene_,
+				  OBSWeakSource transition_)
+		: scene(scene_),
+		  transition(transition_),
+		  usePreviousScene(false)
+	{
+	}
+};

src/headers/switch-idle.hpp

@@ -0,0 +1,16 @@
+#pragma once
+#include <string>
+#include "utility.hpp"
+#include "switch-generic.hpp"
+
+constexpr auto default_idle_time = 60;
+constexpr auto idle_func = 2;
+constexpr auto default_priority_2 = idle_func;
+
+struct IdleData : SceneSwitcherEntry {
+	bool idleEnable = false;
+	int time = default_idle_time;
+	bool alreadySwitched = false;
+
+	const char *getType() { return "idle"; }
+};

src/headers/switch-media.hpp

@@ -0,0 +1,50 @@
+#pragma once
+#include <string>
+#include "utility.hpp"
+#include "switch-generic.hpp"
+
+constexpr auto media_func = 6;
+constexpr auto default_priority_6 = media_func;
+
+typedef enum {
+	TIME_RESTRICTION_NONE,
+	TIME_RESTRICTION_SHORTER,
+	TIME_RESTRICTION_LONGER,
+	TIME_RESTRICTION_REMAINING_SHORTER,
+	TIME_RESTRICTION_REMAINING_LONGER,
+} time_restriction;
+
+struct MediaSwitch : SceneSwitcherEntry {
+	OBSWeakSource source;
+	obs_media_state state;
+	time_restriction restriction;
+	int64_t time;
+	bool matched;
+	std::string mediaSwitchStr;
+
+	const char *getType() { return "meida"; }
+
+	bool valid()
+	{
+		return (usePreviousScene || WeakSourceValid(scene)) &&
+		       WeakSourceValid(source) && WeakSourceValid(transition);
+	}
+
+	inline MediaSwitch(OBSWeakSource scene_, OBSWeakSource source_,
+			   OBSWeakSource transition_, obs_media_state state_,
+			   time_restriction restriction_, uint64_t time_,
+			   bool usePreviousScene_, std::string mediaSwitchStr_)
+		: SceneSwitcherEntry(scene_, transition_, usePreviousScene_),
+		  source(source_),
+		  state(state_),
+		  restriction(restriction_),
+		  time(time_),
+		  mediaSwitchStr(mediaSwitchStr_)
+	{
+	}
+};
+
+static inline QString
+MakeMediaSwitchName(const QString &source, const QString &scene,
+		    const QString &transition, obs_media_state state,
+		    time_restriction restriction, uint64_t time);

src/headers/switch-random.hpp

@@ -0,0 +1,23 @@
+#pragma once
+#include <string>
+#include "utility.hpp"
+#include "switch-generic.hpp"
+
+struct RandomSwitch : SceneSwitcherEntry {
+	double delay;
+	std::string randomSwitchStr;
+
+	const char *getType() { return "random"; }
+
+	inline RandomSwitch(OBSWeakSource scene_, OBSWeakSource transition_,
+			    double delay_, std::string str)
+		: SceneSwitcherEntry(scene_, transition_),
+		  delay(delay_),
+		  randomSwitchStr(str)
+	{
+	}
+};
+
+static inline QString MakeRandomSwitchName(const QString &scene,
+					   const QString &transition,
+					   double &delay);

src/headers/switch-screen-region.hpp

@@ -0,0 +1,32 @@
+#pragma once
+#include <string>
+#include "utility.hpp"
+#include "switch-generic.hpp"
+
+constexpr auto screen_region_func = 4;
+constexpr auto default_priority_4 = screen_region_func;
+
+struct ScreenRegionSwitch : SceneSwitcherEntry {
+	int minX, minY, maxX, maxY;
+	std::string regionStr;
+
+	const char *getType() { return "region"; }
+
+	inline ScreenRegionSwitch(OBSWeakSource scene_,
+				  OBSWeakSource transition_, int minX_,
+				  int minY_, int maxX_, int maxY_,
+				  std::string regionStr_)
+		: SceneSwitcherEntry(scene_, transition_),
+		  minX(minX_),
+		  minY(minY_),
+		  maxX(maxX_),
+		  maxY(maxY_),
+		  regionStr(regionStr_)
+	{
+	}
+};
+
+static inline QString MakeScreenRegionSwitchName(const QString &scene,
+						 const QString &transition,
+						 int minX, int minY, int maxX,
+						 int maxY);

src/headers/switch-time.hpp

@@ -0,0 +1,43 @@
+#pragma once
+#include <string>
+#include <QDateTime>
+#include "utility.hpp"
+#include "switch-generic.hpp"
+
+constexpr auto time_func = 7;
+constexpr auto default_priority_7 = time_func;
+
+typedef enum {
+	ANY_DAY = 0,
+	MONDAY = 1,
+	TUSEDAY = 2,
+	WEDNESDAY = 3,
+	THURSDAY = 4,
+	FRIDAY = 5,
+	SATURDAY = 6,
+	SUNDAY = 7,
+	LIVE = 8
+} timeTrigger;
+
+struct TimeSwitch : SceneSwitcherEntry {
+	timeTrigger trigger;
+	QTime time;
+	std::string timeSwitchStr;
+
+	const char *getType() { return "time"; }
+
+	inline TimeSwitch(OBSWeakSource scene_, OBSWeakSource transition_,
+			  timeTrigger trigger_, QTime time_,
+			  bool usePreviousScene_, std::string timeSwitchStr_)
+		: SceneSwitcherEntry(scene_, transition_, usePreviousScene_),
+		  trigger(trigger_),
+		  time(time_),
+		  timeSwitchStr(timeSwitchStr_)
+	{
+	}
+};
+
+static inline QString MakeTimeSwitchName(const QString &scene,
+					 const QString &transition,
+					 const timeTrigger &trigger,
+					 const QTime &time);

src/headers/switch-transitions.hpp

@@ -0,0 +1,47 @@
+#pragma once
+#include <string>
+#include "utility.hpp"
+#include "switch-generic.hpp"
+
+struct SceneTransition : SceneSwitcherEntry {
+	OBSWeakSource scene2;
+	std::string sceneTransitionStr;
+
+	const char *getType() { return "transition"; }
+
+	bool valid()
+	{
+		return (WeakSourceValid(scene) && WeakSourceValid(scene2)) &&
+		       WeakSourceValid(transition);
+	}
+
+	inline SceneTransition(OBSWeakSource scene_, OBSWeakSource scene2_,
+			       OBSWeakSource transition_,
+			       std::string sceneTransitionStr_)
+		: SceneSwitcherEntry(scene_, transition_),
+		  scene2(scene2_),
+		  sceneTransitionStr(sceneTransitionStr_)
+	{
+	}
+};
+
+static inline QString MakeSceneTransitionName(const QString &scene1,
+					      const QString &scene2,
+					      const QString &transition);
+
+struct DefaultSceneTransition : SceneSwitcherEntry {
+	std::string sceneTransitionStr;
+
+	const char *getType() { return "def_transition"; }
+
+	inline DefaultSceneTransition(OBSWeakSource scene_,
+				      OBSWeakSource transition_,
+				      std::string sceneTransitionStr_)
+		: SceneSwitcherEntry(scene_, transition_),
+		  sceneTransitionStr(sceneTransitionStr_)
+	{
+	}
+};
+
+static inline QString MakeDefaultSceneTransitionName(const QString &scene,
+						     const QString &transition);

src/headers/switch-window.hpp

@@ -0,0 +1,33 @@
+#pragma once
+#include <string>
+#include "utility.hpp"
+#include "switch-generic.hpp"
+
+constexpr auto window_title_func = 5;
+constexpr auto default_priority_5 = window_title_func;
+
+struct WindowSceneSwitch : SceneSwitcherEntry {
+	std::string window;
+	bool fullscreen;
+	bool maximized;
+	bool focus;
+
+	const char *getType() { return "window"; }
+
+	inline WindowSceneSwitch(OBSWeakSource scene_, const char *window_,
+				 OBSWeakSource transition_, bool fullscreen_,
+				 bool maximized_, bool focus_)
+		: SceneSwitcherEntry(scene_, transition_),
+		  window(window_),
+		  fullscreen(fullscreen_),
+		  maximized(maximized_),
+		  focus(focus_)
+	{
+	}
+};
+
+static inline QString MakeWindowSwitchName(const QString &scene,
+					   const QString &value,
+					   const QString &transition,
+					   bool fullscreen, bool maximized,
+					   bool focus);

src/headers/switcher-data-structs.hpp

@@ -1,362 +1,27 @@
 #pragma once
 #include <condition_variable>
-#include <chrono>
 #include <string>
 #include <vector>
-#include <regex>
 #include <mutex>
-#include <fstream>
 #include <QDateTime>
 #include <QThread>
 #include <curl/curl.h>
-#include "utility.hpp"
+
+#include "switch-audio.hpp"
+#include "switch-executable.hpp"
+#include "switch-file.hpp"
+#include "switch-idle.hpp"
+#include "switch-media.hpp"
+#include "switch-random.hpp"
+#include "switch-screen-region.hpp"
+#include "switch-time.hpp"
+#include "switch-transitions.hpp"
+#include "switch-window.hpp"
+#include "swtich-sequence.hpp"
 
 constexpr auto default_interval = 300;
-
-constexpr auto default_idle_time = 60;
-
 constexpr auto previous_scene_name = "Previous Scene";
 
-constexpr auto read_file_func = 0;
-constexpr auto round_trip_func = 1;
-constexpr auto idle_func = 2;
-constexpr auto exe_func = 3;
-constexpr auto screen_region_func = 4;
-constexpr auto window_title_func = 5;
-constexpr auto media_func = 6;
-constexpr auto time_func = 7;
-constexpr auto audio_func = 8;
-
-constexpr auto default_priority_0 = read_file_func;
-constexpr auto default_priority_1 = round_trip_func;
-constexpr auto default_priority_2 = idle_func;
-constexpr auto default_priority_3 = exe_func;
-constexpr auto default_priority_4 = screen_region_func;
-constexpr auto default_priority_5 = window_title_func;
-constexpr auto default_priority_6 = media_func;
-constexpr auto default_priority_7 = time_func;
-constexpr auto default_priority_8 = audio_func;
-
-/********************************************************************************
- * Data structs for each scene switching method
- ********************************************************************************/
-struct WindowSceneSwitch {
-	OBSWeakSource scene;
-	std::string window;
-	OBSWeakSource transition;
-	bool fullscreen;
-	bool focus;
-
-	inline WindowSceneSwitch(OBSWeakSource scene_, const char *window_,
-				 OBSWeakSource transition_, bool fullscreen_,
-				 bool focus_)
-		: scene(scene_),
-		  window(window_),
-		  transition(transition_),
-		  fullscreen(fullscreen_),
-		  focus(focus_)
-	{
-	}
-};
-
-struct ExecutableSceneSwitch {
-	OBSWeakSource mScene;
-	OBSWeakSource mTransition;
-	QString mExe;
-	bool mInFocus;
-
-	inline ExecutableSceneSwitch(OBSWeakSource scene,
-				     OBSWeakSource transition,
-				     const QString &exe, bool inFocus)
-		: mScene(scene),
-		  mTransition(transition),
-		  mExe(exe),
-		  mInFocus(inFocus)
-	{
-	}
-};
-
-struct ScreenRegionSwitch {
-	OBSWeakSource scene;
-	OBSWeakSource transition;
-	int minX, minY, maxX, maxY;
-	std::string regionStr;
-
-	inline ScreenRegionSwitch(OBSWeakSource scene_,
-				  OBSWeakSource transition_, int minX_,
-				  int minY_, int maxX_, int maxY_,
-				  std::string regionStr_)
-		: scene(scene_),
-		  transition(transition_),
-		  minX(minX_),
-		  minY(minY_),
-		  maxX(maxX_),
-		  maxY(maxY_),
-		  regionStr(regionStr_)
-	{
-	}
-};
-
-struct SceneRoundTripSwitch {
-	OBSWeakSource scene1;
-	OBSWeakSource scene2;
-	OBSWeakSource transition;
-	double delay;
-	bool usePreviousScene;
-	std::string sceneRoundTripStr;
-
-	inline SceneRoundTripSwitch(OBSWeakSource scene1_,
-				    OBSWeakSource scene2_,
-				    OBSWeakSource transition_, double delay_,
-				    bool usePreviousScene_, std::string str)
-		: scene1(scene1_),
-		  scene2(scene2_),
-		  transition(transition_),
-		  delay(delay_),
-		  usePreviousScene(usePreviousScene_),
-		  sceneRoundTripStr(str)
-	{
-	}
-};
-
-struct RandomSwitch {
-	OBSWeakSource scene;
-	OBSWeakSource transition;
-	double delay;
-	std::string randomSwitchStr;
-
-	inline RandomSwitch(OBSWeakSource scene_, OBSWeakSource transition_,
-			    double delay_, std::string str)
-		: scene(scene_),
-		  transition(transition_),
-		  delay(delay_),
-		  randomSwitchStr(str)
-	{
-	}
-};
-
-struct SceneTransition {
-	OBSWeakSource scene1;
-	OBSWeakSource scene2;
-	OBSWeakSource transition;
-	std::string sceneTransitionStr;
-
-	inline SceneTransition(OBSWeakSource scene1_, OBSWeakSource scene2_,
-			       OBSWeakSource transition_,
-			       std::string sceneTransitionStr_)
-		: scene1(scene1_),
-		  scene2(scene2_),
-		  transition(transition_),
-		  sceneTransitionStr(sceneTransitionStr_)
-	{
-	}
-};
-
-struct DefaultSceneTransition {
-	OBSWeakSource scene;
-	OBSWeakSource transition;
-	std::string sceneTransitionStr;
-
-	inline DefaultSceneTransition(OBSWeakSource scene_,
-				      OBSWeakSource transition_,
-				      std::string sceneTransitionStr_)
-		: scene(scene_),
-		  transition(transition_),
-		  sceneTransitionStr(sceneTransitionStr_)
-	{
-	}
-};
-
-struct FileSwitch {
-	OBSWeakSource scene;
-	OBSWeakSource transition;
-	std::string file;
-	std::string text;
-	bool remote = false;
-	bool useRegex = false;
-	bool useTime = false;
-	QDateTime lastMod;
-
-	inline FileSwitch(OBSWeakSource scene_, OBSWeakSource transition_,
-			  const char *file_, const char *text_, bool remote_,
-			  bool useRegex_, bool useTime_)
-		: scene(scene_),
-		  transition(transition_),
-		  file(file_),
-		  text(text_),
-		  remote(remote_),
-		  useRegex(useRegex_),
-		  useTime(useTime_),
-		  lastMod()
-	{
-	}
-};
-
-struct FileIOData {
-	bool readEnabled = false;
-	std::string readPath;
-	bool writeEnabled = false;
-	std::string writePath;
-};
-
-struct IdleData {
-	bool idleEnable = false;
-	int time = default_idle_time;
-	OBSWeakSource scene;
-	OBSWeakSource transition;
-	bool usePreviousScene;
-	bool alreadySwitched = false;
-};
-
-struct MediaSwitch {
-	OBSWeakSource scene;
-	OBSWeakSource source;
-	OBSWeakSource transition;
-	obs_media_state state;
-	int64_t time;
-	time_restriction restriction;
-	bool matched;
-	bool usePreviousScene;
-	std::string mediaSwitchStr;
-
-	inline MediaSwitch(OBSWeakSource scene_, OBSWeakSource source_,
-			   OBSWeakSource transition_, obs_media_state state_,
-			   time_restriction restriction_, uint64_t time_,
-			   bool usePreviousScene_, std::string mediaSwitchStr_)
-		: scene(scene_),
-		  source(source_),
-		  transition(transition_),
-		  state(state_),
-		  restriction(restriction_),
-		  time(time_),
-		  usePreviousScene(usePreviousScene_),
-		  mediaSwitchStr(mediaSwitchStr_)
-	{
-	}
-};
-
-struct TimeSwitch {
-	OBSWeakSource scene;
-	OBSWeakSource transition;
-	timeTrigger trigger;
-	QTime time;
-	bool usePreviousScene;
-	std::string timeSwitchStr;
-
-	inline TimeSwitch(OBSWeakSource scene_, OBSWeakSource transition_,
-			  timeTrigger trigger_, QTime time_,
-			  bool usePreviousScene_, std::string timeSwitchStr_)
-		: scene(scene_),
-		  transition(transition_),
-		  trigger(trigger_),
-		  time(time_),
-		  usePreviousScene(usePreviousScene_),
-		  timeSwitchStr(timeSwitchStr_)
-	{
-	}
-};
-
-struct AudioSwitch {
-	OBSWeakSource scene;
-	OBSWeakSource audioSource;
-	OBSWeakSource transition;
-	int volumeThreshold;
-	float peak;
-	bool usePreviousScene;
-	obs_volmeter_t *volmeter;
-	std::string audioSwitchStr;
-
-	static void setVolumeLevel(void *data,
-				   const float magnitude[MAX_AUDIO_CHANNELS],
-				   const float peak[MAX_AUDIO_CHANNELS],
-				   const float inputPeak[MAX_AUDIO_CHANNELS])
-	{
-		UNUSED_PARAMETER(magnitude);
-		UNUSED_PARAMETER(inputPeak);
-		AudioSwitch *s = static_cast<AudioSwitch *>(data);
-
-		s->peak = peak[0];
-		for (int i = 1; i < MAX_AUDIO_CHANNELS; i++)
-			if (peak[i] > s->peak)
-				s->peak = peak[i];
-	}
-
-	inline AudioSwitch(OBSWeakSource scene_, OBSWeakSource transition_,
-			   OBSWeakSource audioSource_, int volumeThreshold_,
-			   bool usePreviousScene_, std::string audioSwitchStr_)
-		: scene(scene_),
-		  transition(transition_),
-		  audioSource(audioSource_),
-		  volumeThreshold(volumeThreshold_),
-		  usePreviousScene(usePreviousScene_),
-		  audioSwitchStr(audioSwitchStr_)
-	{
-		volmeter = obs_volmeter_create(OBS_FADER_LOG);
-		obs_volmeter_add_callback(volmeter, setVolumeLevel, this);
-		obs_source_t *as = obs_weak_source_get_source(audioSource);
-		if (!obs_volmeter_attach_source(volmeter, as)) {
-			const char *name = obs_source_get_name(as);
-			blog(LOG_WARNING,
-			     "failed to attach volmeter to source %s", name);
-		}
-		obs_source_release(as);
-	}
-
-	AudioSwitch(const AudioSwitch &other)
-		: scene(other.scene),
-		  transition(other.transition),
-		  audioSource(other.audioSource),
-		  volumeThreshold(other.volumeThreshold),
-		  usePreviousScene(other.usePreviousScene),
-		  audioSwitchStr(other.audioSwitchStr)
-	{
-		volmeter = obs_volmeter_create(OBS_FADER_LOG);
-		obs_volmeter_add_callback(volmeter, setVolumeLevel, this);
-		obs_source_t *as =
-			obs_weak_source_get_source(other.audioSource);
-		if (!obs_volmeter_attach_source(volmeter, as)) {
-			const char *name = obs_source_get_name(as);
-			blog(LOG_WARNING,
-			     "failed to attach volmeter to source %s", name);
-		}
-		obs_source_release(as);
-	}
-
-	AudioSwitch(AudioSwitch &&other)
-		: scene(other.scene),
-		  transition(other.transition),
-		  audioSource(other.audioSource),
-		  volumeThreshold(other.volumeThreshold),
-		  usePreviousScene(other.usePreviousScene),
-		  audioSwitchStr(other.audioSwitchStr),
-		  volmeter(other.volmeter)
-	{
-		other.volmeter = nullptr;
-	}
-
-	inline ~AudioSwitch()
-	{
-		obs_volmeter_remove_callback(volmeter, setVolumeLevel, this);
-		obs_volmeter_destroy(volmeter);
-	}
-
-	AudioSwitch &operator=(const AudioSwitch &other)
-	{
-		return *this = AudioSwitch(other);
-	}
-
-	AudioSwitch &operator=(AudioSwitch &&other) noexcept
-	{
-		if (this == &other) {
-			return *this;
-		}
-		obs_volmeter_destroy(volmeter);
-		volmeter = other.volmeter;
-		other.volmeter = nullptr;
-		return *this;
-	}
-};
-
 typedef enum { NO_SWITCH = 0, SWITCH = 1, RANDOM_SWITCH = 2 } NoMatch;
 typedef enum { PERSIST = 0, START = 1, STOP = 2 } StartupBehavior;
 typedef enum {
@@ -384,7 +49,7 @@ struct SwitcherData {
 
 	int interval = default_interval;
 
-	obs_source_t *waitScene = NULL; //scene during which wait started
+	obs_source_t *waitScene = NULL;
 	OBSWeakSource previousScene = NULL;
 	OBSWeakSource PreviousScene2 = NULL;
 	OBSWeakSource lastRandomScene;
@@ -404,8 +69,8 @@ struct SwitcherData {
 
 	std::vector<std::string> ignoreWindowsSwitches;
 
-	std::vector<SceneRoundTripSwitch> sceneRoundTripSwitches;
-	int sceneRoundTripUnitMultiplier = 1;
+	std::vector<SceneSequenceSwitch> sceneSequenceSwitches;
+	int sceneSequenceMultiplier = 1;
 
 	std::vector<RandomSwitch> randomSwitches;
 
@@ -479,7 +144,7 @@ struct SwitcherData {
 	void autoStopStreamAndRecording();
 	void autoStartStreamRecording();
 	bool checkPause();
-	void checkSceneRoundTrip(bool &match, OBSWeakSource &scene,
+	void checkSceneSequence(bool &match, OBSWeakSource &scene,
 				 OBSWeakSource &transition,
 				 std::unique_lock<std::mutex> &lock);
 	void checkIdleSwitch(bool &match, OBSWeakSource &scene,
@@ -506,7 +171,7 @@ struct SwitcherData {
 	void saveWindowTitleSwitches(obs_data_t *obj);
 	void saveScreenRegionSwitches(obs_data_t *obj);
 	void savePauseSwitches(obs_data_t *obj);
-	void saveSceneRoundTripSwitches(obs_data_t *obj);
+	void saveSceneSequenceSwitches(obs_data_t *obj);
 	void saveSceneTransitions(obs_data_t *obj);
 	void saveIdleSwitches(obs_data_t *obj);
 	void saveExecutableSwitches(obs_data_t *obj);
@@ -520,7 +185,7 @@ struct SwitcherData {
 	void loadWindowTitleSwitches(obs_data_t *obj);
 	void loadScreenRegionSwitches(obs_data_t *obj);
 	void loadPauseSwitches(obs_data_t *obj);
-	void loadSceneRoundTripSwitches(obs_data_t *obj);
+	void loadSceneSequenceSwitches(obs_data_t *obj);
 	void loadSceneTransitions(obs_data_t *obj);
 	void loadIdleSwitches(obs_data_t *obj);
 	void loadExecutableSwitches(obs_data_t *obj);
@@ -531,124 +196,7 @@ struct SwitcherData {
 	void loadAudioSwitches(obs_data_t *obj);
 	void loadGeneralSettings(obs_data_t *obj);
 
-	void Prune()
-	{
-		for (size_t i = 0; i < windowSwitches.size(); i++) {
-			WindowSceneSwitch &s = windowSwitches[i];
-			if (!WeakSourceValid(s.scene) ||
-			    !WeakSourceValid(s.transition))
-				windowSwitches.erase(windowSwitches.begin() +
-						     i--);
-		}
-
-		if (nonMatchingScene && !WeakSourceValid(nonMatchingScene)) {
-			switchIfNotMatching = NO_SWITCH;
-			nonMatchingScene = nullptr;
-		}
-
-		for (size_t i = 0; i < randomSwitches.size(); i++) {
-			RandomSwitch &s = randomSwitches[i];
-			if (!WeakSourceValid(s.scene) ||
-			    !WeakSourceValid(s.transition))
-				randomSwitches.erase(randomSwitches.begin() +
-						     i--);
-		}
-
-		for (size_t i = 0; i < screenRegionSwitches.size(); i++) {
-			ScreenRegionSwitch &s = screenRegionSwitches[i];
-			if (!WeakSourceValid(s.scene) ||
-			    !WeakSourceValid(s.transition))
-				screenRegionSwitches.erase(
-					screenRegionSwitches.begin() + i--);
-		}
-
-		for (size_t i = 0; i < pauseScenesSwitches.size(); i++) {
-			OBSWeakSource &scene = pauseScenesSwitches[i];
-			if (!WeakSourceValid(scene))
-				pauseScenesSwitches.erase(
-					pauseScenesSwitches.begin() + i--);
-		}
-
-		for (size_t i = 0; i < sceneRoundTripSwitches.size(); i++) {
-			SceneRoundTripSwitch &s = sceneRoundTripSwitches[i];
-			if (!WeakSourceValid(s.scene1) ||
-			    (!s.usePreviousScene &&
-			     !WeakSourceValid(s.scene2)) ||
-			    !WeakSourceValid(s.transition))
-				sceneRoundTripSwitches.erase(
-					sceneRoundTripSwitches.begin() + i--);
-		}
-
-		if (!WeakSourceValid(autoStopScene)) {
-			autoStopScene = nullptr;
-			autoStopEnable = false;
-		}
-
-		for (size_t i = 0; i < sceneTransitions.size(); i++) {
-			SceneTransition &s = sceneTransitions[i];
-			if (!WeakSourceValid(s.scene1) ||
-			    !WeakSourceValid(s.scene2) ||
-			    !WeakSourceValid(s.transition))
-				sceneTransitions.erase(
-					sceneTransitions.begin() + i--);
-		}
-
-		for (size_t i = 0; i < defaultSceneTransitions.size(); i++) {
-			DefaultSceneTransition &s = defaultSceneTransitions[i];
-			if (!WeakSourceValid(s.scene) ||
-			    !WeakSourceValid(s.transition))
-				defaultSceneTransitions.erase(
-					defaultSceneTransitions.begin() + i--);
-		}
-
-		for (size_t i = 0; i < executableSwitches.size(); i++) {
-			ExecutableSceneSwitch &s = executableSwitches[i];
-			if (!WeakSourceValid(s.mScene) ||
-			    !WeakSourceValid(s.mTransition))
-				executableSwitches.erase(
-					executableSwitches.begin() + i--);
-		}
-
-		for (size_t i = 0; i < fileSwitches.size(); i++) {
-			FileSwitch &s = fileSwitches[i];
-			if (!WeakSourceValid(s.scene) ||
-			    !WeakSourceValid(s.transition))
-				fileSwitches.erase(fileSwitches.begin() + i--);
-		}
-
-		for (size_t i = 0; i < timeSwitches.size(); i++) {
-			TimeSwitch &s = timeSwitches[i];
-			if ((!s.usePreviousScene &&
-			     !WeakSourceValid(s.scene)) ||
-			    !WeakSourceValid(s.transition))
-				timeSwitches.erase(timeSwitches.begin() + i--);
-		}
-
-		if (!idleData.usePreviousScene &&
-			    !WeakSourceValid(idleData.scene) ||
-		    !WeakSourceValid(idleData.transition)) {
-			idleData.idleEnable = false;
-		}
-
-		for (size_t i = 0; i < mediaSwitches.size(); i++) {
-			MediaSwitch &s = mediaSwitches[i];
-			if ((!s.usePreviousScene &&
-			     !WeakSourceValid(s.scene)) ||
-			    !WeakSourceValid(s.source) ||
-			    !WeakSourceValid(s.transition))
-				mediaSwitches.erase(mediaSwitches.begin() +
-						    i--);
-		}
-
-		for (size_t i = 0; i < audioSwitches.size(); i++) {
-			AudioSwitch &s = audioSwitches[i];
-			if ((!s.usePreviousScene &&
-			     !WeakSourceValid(s.scene)) ||
-			    !WeakSourceValid(s.transition))
-				audioSwitches.erase(audioSwitches.begin() +
-						    i--);
-		}
-	}
+	void Prune();
 	inline ~SwitcherData() { Stop(); }
 };
 

src/headers/swtich-sequence.hpp

@@ -0,0 +1,44 @@
+#pragma once
+#include <string>
+#include "utility.hpp"
+#include "switch-generic.hpp"
+
+constexpr auto round_trip_func = 1;
+constexpr auto default_priority_1 = round_trip_func;
+
+struct SceneSequenceSwitch : SceneSwitcherEntry {
+	OBSWeakSource startScene;
+	double delay;
+	std::string sceneSequenceStr;
+
+	const char *getType() { return "sequence"; }
+
+	bool valid()
+	{
+		return WeakSourceValid(startScene) &&
+		       (usePreviousScene || WeakSourceValid(scene)) &&
+		       WeakSourceValid(transition);
+	}
+
+	void logSleep(int dur)
+	{
+		blog(LOG_INFO, "Advanced Scene Switcher sequence sleep %d",
+		     dur);
+	}
+
+	inline SceneSequenceSwitch(OBSWeakSource startScene_,
+				    OBSWeakSource scene_,
+				    OBSWeakSource transition_, double delay_,
+				    bool usePreviousScene_, std::string str)
+		: SceneSwitcherEntry(scene_, transition_, usePreviousScene_),
+		  startScene(startScene_),
+		  delay(delay_),
+		  sceneSequenceStr(str)
+	{
+	}
+};
+
+static inline QString MakeSceneSequenceSwitchName(const QString &scene1,
+						   const QString &scene2,
+						   const QString &transition,
+						   double delay);

src/headers/utility.hpp

@@ -11,232 +11,6 @@ static inline bool WeakSourceValid(obs_weak_source_t *ws)
 	return !!source;
 }
 
-static inline QString MakeSwitchName(const QString &scene, const QString &value,
-				     const QString &transition, bool fullscreen,
-				     bool focus)
-{
-	QString name = QStringLiteral("[") + scene + QStringLiteral(", ") +
-		       transition + QStringLiteral("]: ") + value;
-
-	if (fullscreen || focus) {
-		name += QStringLiteral(" (only if");
-
-		if (fullscreen)
-			name += QStringLiteral(" fullscreen");
-		if (fullscreen && focus)
-			name += QStringLiteral(" and");
-		if (focus)
-			name += QStringLiteral(" focused");
-
-		name += QStringLiteral(")");
-	}
-
-	return name;
-}
-
-static inline QString MakeSwitchNameExecutable(const QString &scene,
-					       const QString &value,
-					       const QString &transition,
-					       bool inFocus)
-{
-	if (!inFocus)
-		return QStringLiteral("[") + scene + QStringLiteral(", ") +
-		       transition + QStringLiteral("]: ") + value;
-	return QStringLiteral("[") + scene + QStringLiteral(", ") + transition +
-	       QStringLiteral("]: ") + value +
-	       QStringLiteral(" (only if focused)");
-}
-
-static inline QString MakeScreenRegionSwitchName(const QString &scene,
-						 const QString &transition,
-						 int minX, int minY, int maxX,
-						 int maxY)
-{
-	return QStringLiteral("[") + scene + QStringLiteral(", ") + transition +
-	       QStringLiteral("]: ") + QString::number(minX) +
-	       QStringLiteral(", ") + QString::number(minY) +
-	       QStringLiteral(" x ") + QString::number(maxX) +
-	       QStringLiteral(", ") + QString::number(maxY);
-}
-
-static inline QString MakeSceneRoundTripSwitchName(const QString &scene1,
-						   const QString &scene2,
-						   const QString &transition,
-						   double delay)
-{
-	return scene1 + QStringLiteral(" -> wait for ") +
-	       QString::number(delay) + QStringLiteral(" seconds -> ") +
-	       scene2 + QStringLiteral(" (using ") + transition +
-	       QStringLiteral(" transition)");
-}
-
-static inline QString MakeSceneTransitionName(const QString &scene1,
-					      const QString &scene2,
-					      const QString &transition)
-{
-	return scene1 + QStringLiteral(" --- ") + transition +
-	       QStringLiteral(" --> ") + scene2;
-}
-
-static inline QString MakeDefaultSceneTransitionName(const QString &scene,
-						     const QString &transition)
-{
-	return scene + QStringLiteral(" --> ") + transition;
-}
-
-static inline QString MakeRandomSwitchName(const QString &scene,
-					   const QString &transition,
-					   double &delay)
-{
-	return QStringLiteral("[") + scene + QStringLiteral(", ") + transition +
-	       QStringLiteral("]: ") + QString::number(delay) +
-	       QStringLiteral(" seconds");
-}
-
-static inline QString MakeFileSwitchName(const QString &scene,
-					 const QString &transition,
-					 const QString &fileName,
-					 const QString &text, bool useRegex,
-					 bool useTime)
-{
-	QString switchName = QStringLiteral("Switch to ") + scene +
-			     QStringLiteral(" using ") + transition +
-			     QStringLiteral(" if ") + fileName;
-	if (useTime)
-		switchName += QStringLiteral(" was modified and");
-	switchName += QStringLiteral(" contains");
-	if (useRegex)
-		switchName += QStringLiteral(" (RegEx): \n\"");
-	else
-		switchName += QStringLiteral(": \n\"");
-	if (text.length() > 30)
-		switchName += text.left(27) + QStringLiteral("...\"");
-	else
-		switchName += text + QStringLiteral("\"");
-
-	return switchName;
-}
-
-typedef enum {
-	TIME_RESTRICTION_NONE,
-	TIME_RESTRICTION_SHORTER,
-	TIME_RESTRICTION_LONGER,
-	TIME_RESTRICTION_REMAINING_SHORTER,
-	TIME_RESTRICTION_REMAINING_LONGER,
-} time_restriction;
-
-static inline QString
-MakeMediaSwitchName(const QString &source, const QString &scene,
-		    const QString &transition, obs_media_state state,
-		    time_restriction restriction, uint64_t time)
-{
-	QString switchName = QStringLiteral("Switch to ") + scene +
-			     QStringLiteral(" using ") + transition +
-			     QStringLiteral(" if ") + source +
-			     QStringLiteral(" state is ");
-	if (state == OBS_MEDIA_STATE_NONE) {
-		switchName += QStringLiteral("none");
-	} else if (state == OBS_MEDIA_STATE_PLAYING) {
-		switchName += QStringLiteral("playing");
-	} else if (state == OBS_MEDIA_STATE_OPENING) {
-		switchName += QStringLiteral("opening");
-	} else if (state == OBS_MEDIA_STATE_BUFFERING) {
-		switchName += QStringLiteral("buffering");
-	} else if (state == OBS_MEDIA_STATE_PAUSED) {
-		switchName += QStringLiteral("paused");
-	} else if (state == OBS_MEDIA_STATE_STOPPED) {
-		switchName += QStringLiteral("stopped");
-	} else if (state == OBS_MEDIA_STATE_ENDED) {
-		switchName += QStringLiteral("ended");
-	} else if (state == OBS_MEDIA_STATE_ERROR) {
-		switchName += QStringLiteral("error");
-	}
-	if (restriction == TIME_RESTRICTION_SHORTER) {
-		switchName += QStringLiteral(" and time shorter than ");
-	} else if (restriction == TIME_RESTRICTION_LONGER) {
-		switchName += QStringLiteral(" and time longer than ");
-	} else if (restriction == TIME_RESTRICTION_REMAINING_SHORTER) {
-		switchName +=
-			QStringLiteral(" and time remaining shorter than ");
-	} else if (restriction == TIME_RESTRICTION_REMAINING_LONGER) {
-		switchName +=
-			QStringLiteral(" and time remaining longer than ");
-	}
-	if (restriction != TIME_RESTRICTION_NONE) {
-		switchName += std::to_string(time).c_str();
-		switchName += QStringLiteral(" ms");
-	}
-	return switchName;
-}
-
-typedef enum {
-	ANY_DAY = 0,
-	MONDAY = 1,
-	TUSEDAY = 2,
-	WEDNESDAY = 3,
-	THURSDAY = 4,
-	FRIDAY = 5,
-	SATURDAY = 6,
-	SUNDAY = 7,
-	LIVE = 8
-} timeTrigger;
-
-static inline QString MakeTimeSwitchName(const QString &scene,
-					 const QString &transition,
-					 const timeTrigger &trigger,
-					 const QTime &time)
-{
-	QString switchName;
-
-	switch (trigger) {
-	case ANY_DAY:
-		switchName = QStringLiteral("On any weekday");
-		break;
-	case MONDAY:
-		switchName = QStringLiteral("Mondays");
-		break;
-	case TUSEDAY:
-		switchName = QStringLiteral("Tusedays");
-		break;
-	case WEDNESDAY:
-		switchName = QStringLiteral("Wednesdays");
-		break;
-	case THURSDAY:
-		switchName = QStringLiteral("Thursdays");
-		break;
-	case FRIDAY:
-		switchName = QStringLiteral("Fridays");
-		break;
-	case SATURDAY:
-		switchName = QStringLiteral("Saturdays");
-		break;
-	case SUNDAY:
-		switchName = QStringLiteral("Sundays");
-		break;
-	case LIVE:
-		switchName = QStringLiteral(
-			"Relative to starting streaming / recording");
-		break;
-	}
-	switchName += QStringLiteral(" at ") + time.toString() +
-		      QStringLiteral(" switch to ") + scene +
-		      QStringLiteral(" using ") + transition;
-	return switchName;
-}
-
-static inline QString MakeAudioSwitchName(const QString &scene,
-					  const QString &transition,
-					  const QString &audioSrouce,
-					  const int &volume)
-{
-	QString switchName = QStringLiteral("When volume of ") + audioSrouce +
-			     QStringLiteral(" is above ") +
-			     QString::number(volume) +
-			     QStringLiteral("% switch to ") + scene +
-			     QStringLiteral(" using ") + transition;
-	return switchName;
-}
-
 static inline std::string GetWeakSourceName(obs_weak_source_t *weak_source)
 {
 	std::string name;