MuSync/preferences.cpp at master · Cynnexis/MuSync · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
#include "preferences.h"

Preferences* Preferences::pref;

Preferences::Preferences(QObject *parent) : QObject(parent) {
	if (!isFirstLaunch()) {
		// Init
		initStartupBehaviour();
		initCloseButtonMinimized();
		initStyle();
		initRefreshTimeout();

		// Last
		initFirstLaunch();
	}
}

Preferences* Preferences::getInstance(QObject* parent) {
	if (Preferences::pref == nullptr)
		Preferences::pref = new Preferences(parent);

	return Preferences::pref;
}

bool Preferences::isFirstLaunch() {
	return settings.value("app/firstLaunch", defaultFirstLaunch()).toBool();
}

void Preferences::setFirstLaunch(const bool& firstLaunch) {
	settings.setValue("app/firstLaunch", firstLaunch);
	emit firstLaunchChanged(firstLaunch);
}

bool Preferences::defaultFirstLaunch() {
	return true;
}

void Preferences::initFirstLaunch() {
	setFirstLaunch(defaultFirstLaunch());
}

int Preferences::getStartupBehavior() {
	bool ok = false;
	int startupBehaviour = settings.value("app/startupBehaviour", defaultStartupBehaviour()).toInt(&ok);

	if (ok && isStartupBehaviourValid(startupBehaviour))
		return startupBehaviour;
	else {
		initStartupBehaviour();
		return getStartupBehavior();
	}
}

void Preferences::setStartupBehaviour(const int& startupBehaviour) {
	if (isStartupBehaviourValid(startupBehaviour)) {
		settings.setValue("app/startupBehaviour", startupBehaviour);
		emit startupBehaviourChanged(startupBehaviour);
	}
}

int Preferences::defaultStartupBehaviour() {
	return DONT_OPEN_AT_STARTUP;
}

void Preferences::initStartupBehaviour() {
	setStartupBehaviour(defaultStartupBehaviour());
}

bool Preferences::isStartupBehaviourValid(const int& startupBehaviour) {
	return startupBehaviour >= 0 && startupBehaviour <= 2;
}

bool Preferences::getCloseButtonMinimized() {
	return settings.value("app/closeButtonMinimized", defaultCloseButtonMinimized()).toBool();
}

void Preferences::setCloseButtonMinimized(const bool& closeButtonMinimized) {
	settings.setValue("app/closeButtonMinimized", closeButtonMinimized);
	emit closeButtonMinimizedChanged(closeButtonMinimized);
}

bool Preferences::defaultCloseButtonMinimized() {
	return false;
}

void Preferences::initCloseButtonMinimized() {
	setCloseButtonMinimized(defaultCloseButtonMinimized());
}

int Preferences::getStyle() {
	bool ok = false;
	int style = settings.value("view/style", defaultStyle()).toInt(&ok);

	if (ok && isStyleValid(style))
		return style;
	else {
		initStyle();
		return getStyle();
	}
}

void Preferences::setStyle(const int& style) {
	if (isStyleValid(style)) {
		settings.setValue("view/style", style);
		emit styleChanged(style);
	}
}

int Preferences::defaultStyle() {
	return STYLE_DEFAULT;
}

void Preferences::initStyle() {
	setStyle(defaultStyle());
}

bool Preferences::isStyleValid(const int& style) {
	return 0 <= style && style <= 1;
}

int Preferences::getRefreshTimeout() {
	bool ok = false;
	int refreshTimeout = settings.value("network/refreshTimeout", defaultRefreshTimeout()).toInt(&ok);

	if (ok && isRefreshTimeoutValid(refreshTimeout))
		return refreshTimeout;
	else {
		initRefreshTimeout();
		return getRefreshTimeout();
	}
}

void Preferences::setRefreshTimeout(const int& refreshTimeout) {
	if (isRefreshTimeoutValid(refreshTimeout)) {
		settings.setValue("network/refreshTimeout", refreshTimeout);
		emit refreshTimeoutChanged(refreshTimeout);
	}
}

int Preferences::defaultRefreshTimeout() {
	return 10000; // 10s
}

void Preferences::initRefreshTimeout() {
	setRefreshTimeout(defaultRefreshTimeout());
}

bool Preferences::isRefreshTimeoutValid(const int& refreshTimeout) {
	return 1000 <= refreshTimeout && refreshTimeout <= 3600000;
}

void Preferences::runAppAtStartup(bool runAtStartup) {
	QSettings runSettings("HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\Run",
						  QSettings::NativeFormat);
	if (runAtStartup) {
		runSettings.setValue(qApp->applicationName(),
							 QCoreApplication::applicationFilePath().replace('/', '\\'));
	}
	else
		runSettings.remove(qApp->applicationName());
}

void Preferences::clear() {
	settings.clear();
}