AsuroImgui/AsuroTool/Settings.cpp

#include "ApplicationData.h"
#include "ImguiBase.h"
#include "Util.h"
#include "Settings.h"

#include <chrono>

extern bool justDocked;
extern DrawData* gDrawData;
extern ApplicationData* gAppData;

void initSettings(DrawData& drawData, ApplicationData& appData)
{
	ImGuiSettingsHandler ini_handler;
	ini_handler.TypeName = APPLICATION_SETTINGS_GROUP;
	ini_handler.TypeHash = ImHashStr(APPLICATION_SETTINGS_GROUP);
	ini_handler.ReadOpenFn = settingsReadOpen;
	ini_handler.ReadLineFn = settingsReadLine;
	ini_handler.WriteAllFn = settingsWriteAll;
	GImGui->SettingsHandlers.push_back(ini_handler);
	ImGui::LoadIniSettingsFromDisk("imgui.ini");
	applySettings(drawData, appData);
}

void* settingsReadOpen(ImGuiContext* ctx, ImGuiSettingsHandler* handler, const char* name)
{
	ApplicationSettings* settings = &gAppData->settings;
	*settings = ApplicationSettings();
	return (void*)settings;
}

void settingsReadLine(ImGuiContext* ctx, ImGuiSettingsHandler* handler, void* entry, const char* line)
{
	if (strlen(line) == 0) return;

	ApplicationSettings* settings = (ApplicationSettings*)entry;

	int docked;
	if (sscanf_s(line, "docked=%i", &docked))
	{
		settings->docked = (bool)docked;
	}
	
	int autostart;
	if (sscanf_s(line, "autostart=%i", &autostart))
	{
		settings->autostart = (bool)autostart;
	}
	
	std::string taskName{};
	taskName.resize(MAX_TASK_NAME_LENGTH);
	if (sscanf_s(line, "taskname=%s", &taskName[0], MAX_TASK_NAME_LENGTH))
	{
		settings->taskNames.push_back(taskName);
	}
	
	std::string task{};
	task.resize(MAX_TASK_NAME_LENGTH);
	time_t dayTimestamp;
	if (sscanf_s(line, "task=%lld %s", &dayTimestamp, &task[0], MAX_TASK_NAME_LENGTH))
	{
		if (settings->tasks.contains(task))
		{
			settings->tasks[task].push_back(dayTimestamp);
		}
		else
		{
			settings->tasks.insert({ task, std::vector{ dayTimestamp } });
		}
	}

	std::string baseStationMac{};
	baseStationMac.resize(MAX_MAC_ADDRESS_LENGTH);
	if (sscanf_s(line, "baseStationMac=%s", &baseStationMac[0], MAX_MAC_ADDRESS_LENGTH))
	{
		settings->baseStationMacAdresses.push_back(baseStationMac);
	}

	float timerDuration;
	if (sscanf_s(line, "timerDuration=%f", &timerDuration))
	{
		settings->timerDuration = timerDuration;
	}
	
	float timerRepeatDuration;
	if (sscanf_s(line, "timerRepeatDuration=%f", &timerRepeatDuration))
	{
		settings->timerRepeatDuration = timerRepeatDuration;
	}

	int timerRepeating;
	if (sscanf_s(line, "timerRepeating=%i", &timerRepeating))
	{
		settings->timerRepeating = (bool)timerRepeating;
	}
}

void settingsWriteAll(ImGuiContext* ctx, ImGuiSettingsHandler* handler, ImGuiTextBuffer* outBuf)
{
	outBuf->appendf("[%s][%s]\n", APPLICATION_SETTINGS_GROUP, APPLICATION_SETTINGS_GROUP);
	outBuf->appendf("docked=%i\n", (int)gAppData->settings.docked);
	outBuf->appendf("autostart=%i\n", (int)gAppData->settings.autostart);

	for (std::string& taskName : gAppData->settings.taskNames)
	{
		outBuf->appendf("taskname=%s\n", taskName.c_str());
	}

	for (auto& task : gAppData->settings.tasks)
	{
		for (auto& date : task.second)
		{
			outBuf->appendf("task=%lld %s\n", date, task.first.c_str());
		}
	}

	for (std::string& baseStationMac : gAppData->settings.baseStationMacAdresses)
	{
		outBuf->appendf("baseStationMac=%s\n", baseStationMac.c_str());
	}

	outBuf->appendf("timerDuration=%f\n", gAppData->settings.timerDuration);
	outBuf->appendf("timerRepeatDuration=%f\n", gAppData->settings.timerRepeatDuration);
	outBuf->appendf("timerRepeating=%i\n", (int)gAppData->settings.timerRepeating);
}

void applySettings(DrawData& drawData, ApplicationData& appData)
{
	updateDocked(drawData, appData);
	setAutostart(appData.settings.autostart);
}

void updateDocked(DrawData& drawData, ApplicationData& appData)
{
	justDocked = true;

	glfwSetWindowAttrib(drawData.window, GLFW_DECORATED, !appData.settings.docked);
	ShowWindow(drawData.window_handle, SW_HIDE);
	SetWindowLongPtr(drawData.window_handle, GWL_EXSTYLE, appData.settings.docked ? WS_EX_TOOLWINDOW : 0);
	ShowWindow(drawData.window_handle, SW_SHOW);
}

void setAutostart(bool newValue)
{
	const size_t MAX_PATH_LENGTH = 2048;
	const wchar_t* KEY_APP_NAME = L"AsuroTool";

	HRESULT hr;

	HKEY runKey = nullptr;
	hr = RegCreateKey(HKEY_CURRENT_USER, L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", &runKey);
	if (isError(hr, "Failed to find/create autostart run key: ")) return;

	if (newValue)
	{
		std::wstring appPath;
		if (FAILED(getAppPath(appPath))) return;

		hr = RegSetValueEx(runKey, KEY_APP_NAME, 0, REG_SZ, (BYTE*)appPath.c_str(), static_cast<DWORD>((appPath.size() + 1) * sizeof(wchar_t)));
		if (isError(hr, "Failed to write autostart key: ")) return;
	}
	else
	{
		hr = RegDeleteValue(runKey, KEY_APP_NAME);
		if (isError(hr, "Failed to delete autostart key: ")) return;
	}
}