Add day of week based check to date condition

data/locale/en-US.ini

@@ -238,6 +238,14 @@ AdvSceneSwitcher.condition.replay.state.started="Replay buffer started"
 AdvSceneSwitcher.condition.replay.state.saved="Replay buffer saved"
 AdvSceneSwitcher.condition.replay.entry="{{state}}"
 AdvSceneSwitcher.condition.date="Date"
+AdvSceneSwitcher.condition.date.anyDay="Any day"
+AdvSceneSwitcher.condition.date.monday="Monday"
+AdvSceneSwitcher.condition.date.tuesday="Tuesday"
+AdvSceneSwitcher.condition.date.wednesday="Wednesday"
+AdvSceneSwitcher.condition.date.thursday="Thursday"
+AdvSceneSwitcher.condition.date.friday="Friday"
+AdvSceneSwitcher.condition.date.saturday="Saturday"
+AdvSceneSwitcher.condition.date.sunday="Sunday"
 AdvSceneSwitcher.condition.date.state.at="At"
 AdvSceneSwitcher.condition.date.state.after="After"
 AdvSceneSwitcher.condition.date.state.before="Before"
@@ -245,8 +253,11 @@ AdvSceneSwitcher.condition.date.state.between="Between"
 AdvSceneSwitcher.condition.date.separator="and"
 AdvSceneSwitcher.condition.date.ignoreDate="If unchecked the date component will be ignored"
 AdvSceneSwitcher.condition.date.ignoreTime="If unchecked the time component will be ignored"
-AdvSceneSwitcher.condition.date.entry.line1="{{condition}} {{ignoreDate}}{{date}} {{ignoreTime}}{{time}} {{separator}} {{date2}} {{time2}}"
-AdvSceneSwitcher.condition.date.entry.line2="{{repeat}} Repeat every {{duration}} on date match"
+AdvSceneSwitcher.condition.date.showAdvancedSettings="Show advanced settings"
+AdvSceneSwitcher.condition.date.showSimpleSettings="Show simple settings"
+AdvSceneSwitcher.condition.date.entry.simple="On {{dayOfWeek}} at {{weekTime}}"
+AdvSceneSwitcher.condition.date.entry.advanced="{{condition}} {{ignoreDate}}{{date}} {{ignoreTime}}{{time}} {{separator}} {{date2}} {{time2}}"
+AdvSceneSwitcher.condition.date.entry.repeat="{{repeat}} Repeat every {{duration}} on date match"
 AdvSceneSwitcher.condition.sceneTransform="Scene item transform"
 AdvSceneSwitcher.condition.sceneTransform.getTransform="Get transform"
 AdvSceneSwitcher.condition.sceneTransform.regex="Use regular expressions"

src/headers/macro-condition-date.hpp

@@ -13,6 +13,17 @@ enum class DateCondition {
 	BETWEEN,
 };
 
+enum class DayOfWeekSelection {
+	ANY = 0,
+	MONDAY,
+	TUESDAY,
+	WEDNESDAY,
+	THURSDAY,
+	FRIDAY,
+	SATURDAY,
+	SUNDAY,
+};
+
 class MacroConditionDate : public MacroCondition {
 public:
 	MacroConditionDate(Macro *m) : MacroCondition(m) {}
@@ -26,6 +37,7 @@ public:
 		return std::make_shared<MacroConditionDate>(m);
 	}
 
+	DayOfWeekSelection _dayOfWeek = DayOfWeekSelection::ANY;
 	QDateTime _dateTime = QDateTime::currentDateTime();
 	QDateTime _dateTime2 = QDateTime::currentDateTime();
 	bool _ignoreDate = false;
@@ -33,8 +45,12 @@ public:
 	bool _repeat = false;
 	Duration _duration;
 	DateCondition _condition = DateCondition::AT;
+	bool _dayOfWeekCheck = false;
 
 private:
+	bool checkDayOfWeek();
+	bool checkRegularDate();
+
 	static bool _registered;
 	static const std::string id;
 };
@@ -56,6 +72,7 @@ public:
 	}
 
 private slots:
+	void DayOfWeekChanged(int day);
 	void ConditionChanged(int cond);
 	void DateChanged(const QDate &date);
 	void TimeChanged(const QTime &time);
@@ -66,10 +83,14 @@ private slots:
 	void RepeatChanged(int state);
 	void DurationChanged(double seconds);
 	void DurationUnitChanged(DurationUnit unit);
+	void AdvancedSettingsToggleClicked();
 signals:
 	void HeaderInfoChanged(const QString &);
 
 protected:
+	QComboBox *_dayOfWeek;
+	QTimeEdit *_weekTime;
+
 	QComboBox *_condition;
 	QDateEdit *_date;
 	QTimeEdit *_time;
@@ -80,6 +101,12 @@ protected:
 	QCheckBox *_ignoreTime;
 	QCheckBox *_repeat;
 	DurationSelection *_duration;
+
+	QPushButton *_advancedSettingsTooggle;
+	QHBoxLayout *_simpleLayout;
+	QHBoxLayout *_advancedLayout;
+	QHBoxLayout *_repeatLayout;
+
 	std::shared_ptr<MacroConditionDate> _entryData;
 
 private:

src/macro-condition-date.cpp

@@ -3,6 +3,8 @@
 #include "headers/utility.hpp"
 #include "headers/advanced-scene-switcher.hpp"
 
+#include <QCalendarWidget>
+
 const std::string MacroConditionDate::id = "date";
 
 bool MacroConditionDate::_registered = MacroConditionFactory::Register(
@@ -18,7 +20,34 @@ static std::map<DateCondition, std::string> dateConditionTypes = {
 	 "AdvSceneSwitcher.condition.date.state.between"},
 };
 
-bool MacroConditionDate::CheckCondition()
+static std::map<DayOfWeekSelection, std::string> dayOfWeekNames = {
+	{DayOfWeekSelection::ANY, "AdvSceneSwitcher.condition.date.anyDay"},
+	{DayOfWeekSelection::MONDAY, "AdvSceneSwitcher.condition.date.monday"},
+	{DayOfWeekSelection::TUESDAY,
+	 "AdvSceneSwitcher.condition.date.tuesday"},
+	{DayOfWeekSelection::WEDNESDAY,
+	 "AdvSceneSwitcher.condition.date.wednesday"},
+	{DayOfWeekSelection::THURSDAY,
+	 "AdvSceneSwitcher.condition.date.thursday"},
+	{DayOfWeekSelection::FRIDAY, "AdvSceneSwitcher.condition.date.friday"},
+	{DayOfWeekSelection::SATURDAY,
+	 "AdvSceneSwitcher.condition.date.saturday"},
+	{DayOfWeekSelection::SUNDAY, "AdvSceneSwitcher.condition.date.sunday"},
+};
+
+bool MacroConditionDate::checkDayOfWeek()
+{
+	QDateTime cur = QDateTime::currentDateTime();
+	if (_dayOfWeek != DayOfWeekSelection::ANY &&
+	    cur.date().dayOfWeek() != static_cast<int>(_dayOfWeek)) {
+		return false;
+	}
+	_dateTime.setDate(cur.date());
+	return _dateTime >= cur &&
+	       _dateTime <= cur.addMSecs(switcher->interval);
+}
+
+bool MacroConditionDate::checkRegularDate()
 {
 	bool match = false;
 	QDateTime cur = QDateTime::currentDateTime();
@@ -61,9 +90,18 @@ bool MacroConditionDate::CheckCondition()
 	return match;
 }
 
+bool MacroConditionDate::CheckCondition()
+{
+	if (_dayOfWeekCheck) {
+		return checkDayOfWeek();
+	}
+	return checkRegularDate();
+}
+
 bool MacroConditionDate::Save(obs_data_t *obj)
 {
 	MacroCondition::Save(obj);
+	obs_data_set_int(obj, "dayOfWeek", static_cast<int>(_dayOfWeek));
 	obs_data_set_int(obj, "condition", static_cast<int>(_condition));
 	obs_data_set_string(obj, "dateTime",
 			    _dateTime.toString().toStdString().c_str());
@@ -73,13 +111,15 @@ bool MacroConditionDate::Save(obs_data_t *obj)
 	obs_data_set_bool(obj, "ignoreTime", _ignoreTime);
 	obs_data_set_bool(obj, "repeat", _repeat);
 	_duration.Save(obj);
-
+	obs_data_set_bool(obj, "dayOfWeekCheck", _dayOfWeekCheck);
 	return true;
 }
 
 bool MacroConditionDate::Load(obs_data_t *obj)
 {
 	MacroCondition::Load(obj);
+	_dayOfWeek = static_cast<DayOfWeekSelection>(
+		obs_data_get_int(obj, "dayOfWeek"));
 	_condition =
 		static_cast<DateCondition>(obs_data_get_int(obj, "condition"));
 	_dateTime = QDateTime::fromString(
@@ -90,12 +130,43 @@ bool MacroConditionDate::Load(obs_data_t *obj)
 	_ignoreTime = obs_data_get_bool(obj, "ignoreTime");
 	_repeat = obs_data_get_bool(obj, "repeat");
 	_duration.Load(obj);
+
+	// TODO: Remove this fallback in future version
+	if (!obs_data_has_user_value(obj, "dayOfWeekCheck")) {
+		_dayOfWeekCheck = false;
+	} else {
+		_dayOfWeekCheck = obs_data_get_bool(obj, "dayOfWeekCheck");
+	}
 	return true;
 }
 
 std::string MacroConditionDate::GetShortDesc()
 {
-	return _dateTime.toString().toStdString();
+	if (_dayOfWeekCheck) {
+		auto it = dayOfWeekNames.find(_dayOfWeek);
+		if (it == dayOfWeekNames.end()) {
+			return "";
+		}
+		std::string dayName = obs_module_text(it->second.c_str());
+		return dayName + " " +
+		       _dateTime.time().toString().toStdString();
+	} else {
+		if (!_ignoreDate && !_ignoreTime) {
+			return _dateTime.toString().toStdString();
+		} else if (_ignoreDate && !_ignoreTime) {
+			return _dateTime.time().toString().toStdString();
+		} else if (!_ignoreDate && _ignoreTime) {
+			return _dateTime.date().toString().toStdString();
+		}
+	}
+	return "";
+}
+
+static inline void populateDaySelection(QComboBox *list)
+{
+	for (auto entry : dayOfWeekNames) {
+		list->addItem(obs_module_text(entry.second.c_str()));
+	}
 }
 
 static inline void populateConditionSelection(QComboBox *list)
@@ -105,12 +176,14 @@ static inline void populateConditionSelection(QComboBox *list)
 	}
 }
 
-#include <QCalendarWidget>
-
 MacroConditionDateEdit::MacroConditionDateEdit(
 	QWidget *parent, std::shared_ptr<MacroConditionDate> entryData)
 	: QWidget(parent)
 {
+	_dayOfWeek = new QComboBox();
+	_weekTime = new QTimeEdit();
+	_weekTime->setDisplayFormat("hh:mm:ss");
+
 	_condition = new QComboBox();
 	_date = new QDateEdit();
 	_date->setDisplayFormat("yyyy.MM.dd ");
@@ -134,9 +207,16 @@ MacroConditionDateEdit::MacroConditionDateEdit(
 	_ignoreTime = new QCheckBox();
 	_ignoreTime->setToolTip(
 		obs_module_text("AdvSceneSwitcher.condition.date.ignoreTime"));
+
 	_repeat = new QCheckBox();
 	_duration = new DurationSelection();
+	_advancedSettingsTooggle = new QPushButton(obs_module_text(
+		"AdvSceneSwitcher.condition.date.showAdvancedSettings"));
 
+	QWidget::connect(_dayOfWeek, SIGNAL(currentIndexChanged(int)), this,
+			 SLOT(DayOfWeekChanged(int)));
+	QWidget::connect(_weekTime, SIGNAL(timeChanged(const QTime &)), this,
+			 SLOT(TimeChanged(const QTime &)));
 	QWidget::connect(_condition, SIGNAL(currentIndexChanged(int)), this,
 			 SLOT(ConditionChanged(int)));
 	QWidget::connect(_date, SIGNAL(dateChanged(const QDate &)), this,
@@ -157,11 +237,15 @@ MacroConditionDateEdit::MacroConditionDateEdit(
 			 SLOT(DurationChanged(double)));
 	QWidget::connect(_duration, SIGNAL(UnitChanged(DurationUnit)), this,
 			 SLOT(DurationUnitChanged(DurationUnit)));
+	QWidget::connect(_advancedSettingsTooggle, SIGNAL(clicked()), this,
+			 SLOT(AdvancedSettingsToggleClicked()));
 
+	populateDaySelection(_dayOfWeek);
 	populateConditionSelection(_condition);
 
-	auto line1Layout = new QHBoxLayout;
 	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
+		{"{{dayOfWeek}}", _dayOfWeek},
+		{"{{weekTime}}", _weekTime},
 		{"{{condition}}", _condition},
 		{"{{date}}", _date},
 		{"{{time}}", _time},
@@ -173,17 +257,27 @@ MacroConditionDateEdit::MacroConditionDateEdit(
 		{"{{repeat}}", _repeat},
 		{"{{duration}}", _duration},
 	};
+	_simpleLayout = new QHBoxLayout;
 	placeWidgets(
-		obs_module_text("AdvSceneSwitcher.condition.date.entry.line1"),
-		line1Layout, widgetPlaceholders);
-	auto line2Layout = new QHBoxLayout;
+		obs_module_text("AdvSceneSwitcher.condition.date.entry.simple"),
+		_simpleLayout, widgetPlaceholders);
+	_advancedLayout = new QHBoxLayout;
+	placeWidgets(obs_module_text(
+			     "AdvSceneSwitcher.condition.date.entry.advanced"),
+		     _advancedLayout, widgetPlaceholders);
+	_repeatLayout = new QHBoxLayout;
 	placeWidgets(
-		obs_module_text("AdvSceneSwitcher.condition.date.entry.line2"),
-		line2Layout, widgetPlaceholders);
+		obs_module_text("AdvSceneSwitcher.condition.date.entry.repeat"),
+		_repeatLayout, widgetPlaceholders);
 
 	auto *mainLayout = new QVBoxLayout;
-	mainLayout->addLayout(line1Layout);
-	mainLayout->addLayout(line2Layout);
+	mainLayout->addLayout(_simpleLayout);
+	mainLayout->addLayout(_advancedLayout);
+	mainLayout->addLayout(_repeatLayout);
+	auto *_advancedToggleLayout = new QHBoxLayout;
+	_advancedToggleLayout->addWidget(_advancedSettingsTooggle);
+	_advancedToggleLayout->addStretch();
+	mainLayout->addLayout(_advancedToggleLayout);
 	setLayout(mainLayout);
 
 	_entryData = entryData;
@@ -191,6 +285,18 @@ MacroConditionDateEdit::MacroConditionDateEdit(
 	_loading = false;
 }
 
+void MacroConditionDateEdit::DayOfWeekChanged(int day)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_dayOfWeek = static_cast<DayOfWeekSelection>(day);
+	emit HeaderInfoChanged(
+		QString::fromStdString(_entryData->GetShortDesc()));
+}
+
 void MacroConditionDateEdit::ConditionChanged(int cond)
 {
 	if (_loading || !_entryData) {
@@ -302,12 +408,28 @@ void MacroConditionDateEdit::DurationUnitChanged(DurationUnit unit)
 	_entryData->_duration.displayUnit = unit;
 }
 
+void MacroConditionDateEdit::AdvancedSettingsToggleClicked()
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_dayOfWeekCheck = !_entryData->_dayOfWeekCheck;
+	SetWidgetStatus();
+	emit HeaderInfoChanged(
+		QString::fromStdString(_entryData->GetShortDesc()));
+}
+
 void MacroConditionDateEdit::UpdateEntryData()
 {
 	if (!_entryData) {
 		return;
 	}
 
+	_dayOfWeek->setCurrentIndex(
+		static_cast<int>(static_cast<int>(_entryData->_dayOfWeek)));
+	_weekTime->setTime(_entryData->_dateTime.time());
 	_condition->setCurrentIndex(static_cast<int>(_entryData->_condition));
 	_date->setDate(_entryData->_dateTime.date());
 	_time->setTime(_entryData->_dateTime.time());
@@ -327,12 +449,28 @@ void MacroConditionDateEdit::SetWidgetStatus()
 		return;
 	}
 
-	_date->setDisabled(_entryData->_ignoreDate);
-	_date2->setDisabled(_entryData->_ignoreDate);
-	_time->setDisabled(_entryData->_ignoreTime);
-	_time2->setDisabled(_entryData->_ignoreTime);
-	ShowSecondDateSelection(_entryData->_condition ==
-				DateCondition::BETWEEN);
+	setLayoutVisible(_simpleLayout, _entryData->_dayOfWeekCheck);
+	setLayoutVisible(_advancedLayout, !_entryData->_dayOfWeekCheck);
+	setLayoutVisible(_repeatLayout, !_entryData->_dayOfWeekCheck);
+	if (_entryData->_dayOfWeekCheck) {
+		_advancedSettingsTooggle->setText(obs_module_text(
+			"AdvSceneSwitcher.condition.date.showAdvancedSettings"));
+	} else {
+		_advancedSettingsTooggle->setText(obs_module_text(
+			"AdvSceneSwitcher.condition.date.showSimpleSettings"));
+		_date->setDisabled(_entryData->_ignoreDate);
+		_date2->setDisabled(_entryData->_ignoreDate);
+		_time->setDisabled(_entryData->_ignoreTime);
+		_time2->setDisabled(_entryData->_ignoreTime);
+		ShowSecondDateSelection(_entryData->_condition ==
+					DateCondition::BETWEEN);
+	}
+
+	const QSignalBlocker b1(_weekTime);
+	const QSignalBlocker b2(_weekTime);
+	_weekTime->setTime(_entryData->_dateTime.time());
+	_weekTime->setTime(_entryData->_dateTime.time());
+	adjustSize();
 }
 
 void MacroConditionDateEdit::ShowSecondDateSelection(bool visible)
@@ -340,5 +478,4 @@ void MacroConditionDateEdit::ShowSecondDateSelection(bool visible)
 	_separator->setVisible(visible);
 	_date2->setVisible(visible);
 	_time2->setVisible(visible);
-	adjustSize();
 }

src/macro-condition-weekday.cpp

@@ -0,0 +1,344 @@
+#include "headers/macro-condition-edit.hpp"
+#include "headers/macro-condition-date.hpp"
+#include "headers/utility.hpp"
+#include "headers/advanced-scene-switcher.hpp"
+
+const std::string MacroConditionDate::id = "date";
+
+bool MacroConditionDate::_registered = MacroConditionFactory::Register(
+	MacroConditionDate::id,
+	{MacroConditionDate::Create, MacroConditionDateEdit::Create,
+	 "AdvSceneSwitcher.condition.date", false});
+
+static std::map<DateCondition, std::string> dateConditionTypes = {
+	{DateCondition::AT, "AdvSceneSwitcher.condition.date.state.at"},
+	{DateCondition::AFTER, "AdvSceneSwitcher.condition.date.state.after"},
+	{DateCondition::BEFORE, "AdvSceneSwitcher.condition.date.state.before"},
+	{DateCondition::BETWEEN,
+	 "AdvSceneSwitcher.condition.date.state.between"},
+};
+
+bool MacroConditionDate::CheckCondition()
+{
+	bool match = false;
+	QDateTime cur = QDateTime::currentDateTime();
+	if (_ignoreDate) {
+		_dateTime.setDate(cur.date());
+		_dateTime2.setDate(cur.date());
+	}
+	if (_ignoreTime) {
+		_dateTime.setTime(cur.time());
+		_dateTime2.setTime(cur.time());
+	}
+
+	switch (_condition) {
+	case DateCondition::AT:
+		match = _dateTime >= cur &&
+			_dateTime <= cur.addMSecs(switcher->interval);
+		break;
+	case DateCondition::AFTER:
+		match = cur >= _dateTime;
+		break;
+	case DateCondition::BEFORE:
+		match = cur <= _dateTime;
+		break;
+	case DateCondition::BETWEEN:
+		if (_dateTime2 > _dateTime) {
+			match = cur >= _dateTime && cur <= _dateTime2;
+		} else {
+			match = cur >= _dateTime2 && cur <= _dateTime;
+		}
+		break;
+	default:
+		break;
+	}
+
+	if (match && _repeat) {
+		_dateTime = _dateTime.addSecs(_duration.seconds);
+		_dateTime2 = _dateTime2.addSecs(_duration.seconds);
+	}
+
+	return match;
+}
+
+bool MacroConditionDate::Save(obs_data_t *obj)
+{
+	MacroCondition::Save(obj);
+	obs_data_set_int(obj, "condition", static_cast<int>(_condition));
+	obs_data_set_string(obj, "dateTime",
+			    _dateTime.toString().toStdString().c_str());
+	obs_data_set_string(obj, "dateTime2",
+			    _dateTime2.toString().toStdString().c_str());
+	obs_data_set_bool(obj, "ignoreDate", _ignoreDate);
+	obs_data_set_bool(obj, "ignoreTime", _ignoreTime);
+	obs_data_set_bool(obj, "repeat", _repeat);
+	_duration.Save(obj);
+
+	return true;
+}
+
+bool MacroConditionDate::Load(obs_data_t *obj)
+{
+	MacroCondition::Load(obj);
+	_condition =
+		static_cast<DateCondition>(obs_data_get_int(obj, "condition"));
+	_dateTime = QDateTime::fromString(
+		QString::fromStdString(obs_data_get_string(obj, "dateTime")));
+	_dateTime2 = QDateTime::fromString(
+		QString::fromStdString(obs_data_get_string(obj, "dateTime2")));
+	_ignoreDate = obs_data_get_bool(obj, "ignoreDate");
+	_ignoreTime = obs_data_get_bool(obj, "ignoreTime");
+	_repeat = obs_data_get_bool(obj, "repeat");
+	_duration.Load(obj);
+	return true;
+}
+
+std::string MacroConditionDate::GetShortDesc()
+{
+	return _dateTime.toString().toStdString();
+}
+
+static inline void populateConditionSelection(QComboBox *list)
+{
+	for (auto entry : dateConditionTypes) {
+		list->addItem(obs_module_text(entry.second.c_str()));
+	}
+}
+
+#include <QCalendarWidget>
+
+MacroConditionDateEdit::MacroConditionDateEdit(
+	QWidget *parent, std::shared_ptr<MacroConditionDate> entryData)
+	: QWidget(parent)
+{
+	_condition = new QComboBox();
+	_date = new QDateEdit();
+	_date->setDisplayFormat("yyyy.MM.dd ");
+	_date->setCalendarPopup(true);
+	auto cal = _date->calendarWidget();
+	cal->showSelectedDate();
+	_time = new QTimeEdit();
+	_time->setDisplayFormat("hh:mm:ss");
+	_separator = new QLabel(
+		obs_module_text("AdvSceneSwitcher.condition.date.separator"));
+	_date2 = new QDateEdit();
+	_date2->setDisplayFormat("yyyy.MM.dd ");
+	_date2->setCalendarPopup(true);
+	cal = _date2->calendarWidget();
+	cal->showSelectedDate();
+	_time2 = new QTimeEdit();
+	_time2->setDisplayFormat("hh:mm:ss");
+	_ignoreDate = new QCheckBox();
+	_ignoreDate->setToolTip(
+		obs_module_text("AdvSceneSwitcher.condition.date.ignoreDate"));
+	_ignoreTime = new QCheckBox();
+	_ignoreTime->setToolTip(
+		obs_module_text("AdvSceneSwitcher.condition.date.ignoreTime"));
+	_repeat = new QCheckBox();
+	_duration = new DurationSelection();
+
+	QWidget::connect(_condition, SIGNAL(currentIndexChanged(int)), this,
+			 SLOT(ConditionChanged(int)));
+	QWidget::connect(_date, SIGNAL(dateChanged(const QDate &)), this,
+			 SLOT(DateChanged(const QDate &)));
+	QWidget::connect(_date2, SIGNAL(dateChanged(const QDate &)), this,
+			 SLOT(Date2Changed(const QDate &)));
+	QWidget::connect(_time, SIGNAL(timeChanged(const QTime &)), this,
+			 SLOT(TimeChanged(const QTime &)));
+	QWidget::connect(_time2, SIGNAL(timeChanged(const QTime &)), this,
+			 SLOT(Time2Changed(const QTime &)));
+	QWidget::connect(_ignoreDate, SIGNAL(stateChanged(int)), this,
+			 SLOT(IgnoreDateChanged(int)));
+	QWidget::connect(_ignoreTime, SIGNAL(stateChanged(int)), this,
+			 SLOT(IgnoreTimeChanged(int)));
+	QWidget::connect(_repeat, SIGNAL(stateChanged(int)), this,
+			 SLOT(RepeatChanged(int)));
+	QWidget::connect(_duration, SIGNAL(DurationChanged(double)), this,
+			 SLOT(DurationChanged(double)));
+	QWidget::connect(_duration, SIGNAL(UnitChanged(DurationUnit)), this,
+			 SLOT(DurationUnitChanged(DurationUnit)));
+
+	populateConditionSelection(_condition);
+
+	auto line1Layout = new QHBoxLayout;
+	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
+		{"{{condition}}", _condition},
+		{"{{date}}", _date},
+		{"{{time}}", _time},
+		{"{{separator}}", _separator},
+		{"{{date2}}", _date2},
+		{"{{time2}}", _time2},
+		{"{{ignoreDate}}", _ignoreDate},
+		{"{{ignoreTime}}", _ignoreTime},
+		{"{{repeat}}", _repeat},
+		{"{{duration}}", _duration},
+	};
+	placeWidgets(
+		obs_module_text("AdvSceneSwitcher.condition.date.entry.line1"),
+		line1Layout, widgetPlaceholders);
+	auto line2Layout = new QHBoxLayout;
+	placeWidgets(
+		obs_module_text("AdvSceneSwitcher.condition.date.entry.line2"),
+		line2Layout, widgetPlaceholders);
+
+	auto *mainLayout = new QVBoxLayout;
+	mainLayout->addLayout(line1Layout);
+	mainLayout->addLayout(line2Layout);
+	setLayout(mainLayout);
+
+	_entryData = entryData;
+	UpdateEntryData();
+	_loading = false;
+}
+
+void MacroConditionDateEdit::ConditionChanged(int cond)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_condition = static_cast<DateCondition>(cond);
+	ShowSecondDateSelection(_entryData->_condition ==
+				DateCondition::BETWEEN);
+}
+
+void MacroConditionDateEdit::DateChanged(const QDate &date)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_dateTime.setDate(date);
+
+	emit HeaderInfoChanged(
+		QString::fromStdString(_entryData->GetShortDesc()));
+}
+
+void MacroConditionDateEdit::TimeChanged(const QTime &time)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_dateTime.setTime(time);
+
+	emit HeaderInfoChanged(
+		QString::fromStdString(_entryData->GetShortDesc()));
+}
+
+void MacroConditionDateEdit::Date2Changed(const QDate &date)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_dateTime2.setDate(date);
+}
+
+void MacroConditionDateEdit::Time2Changed(const QTime &time)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_dateTime2.setTime(time);
+}
+
+void MacroConditionDateEdit::IgnoreDateChanged(int state)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_ignoreDate = !state;
+	SetWidgetStatus();
+}
+
+void MacroConditionDateEdit::IgnoreTimeChanged(int state)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_ignoreTime = !state;
+	SetWidgetStatus();
+}
+
+void MacroConditionDateEdit::RepeatChanged(int state)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_repeat = state;
+	_duration->setDisabled(!state);
+}
+
+void MacroConditionDateEdit::DurationChanged(double seconds)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_duration.seconds = seconds;
+}
+
+void MacroConditionDateEdit::DurationUnitChanged(DurationUnit unit)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_duration.displayUnit = unit;
+}
+
+void MacroConditionDateEdit::UpdateEntryData()
+{
+	if (!_entryData) {
+		return;
+	}
+
+	_condition->setCurrentIndex(static_cast<int>(_entryData->_condition));
+	_date->setDate(_entryData->_dateTime.date());
+	_time->setTime(_entryData->_dateTime.time());
+	_date2->setDate(_entryData->_dateTime2.date());
+	_time2->setTime(_entryData->_dateTime2.time());
+	_ignoreDate->setChecked(!_entryData->_ignoreDate);
+	_ignoreTime->setChecked(!_entryData->_ignoreTime);
+	_repeat->setChecked(_entryData->_repeat);
+	_duration->SetDuration(_entryData->_duration);
+	_duration->setDisabled(!_entryData->_repeat);
+	SetWidgetStatus();
+}
+
+void MacroConditionDateEdit::SetWidgetStatus()
+{
+	if (!_entryData) {
+		return;
+	}
+
+	_date->setDisabled(_entryData->_ignoreDate);
+	_date2->setDisabled(_entryData->_ignoreDate);
+	_time->setDisabled(_entryData->_ignoreTime);
+	_time2->setDisabled(_entryData->_ignoreTime);
+	ShowSecondDateSelection(_entryData->_condition ==
+				DateCondition::BETWEEN);
+}
+
+void MacroConditionDateEdit::ShowSecondDateSelection(bool visible)
+{
+	_separator->setVisible(visible);
+	_date2->setVisible(visible);
+	_time2->setVisible(visible);
+	adjustSize();
+}