Changeset View
Changeset View
Standalone View
Standalone View
rules.cpp
Show All 30 Lines | |||||
31 | 31 | | |||
32 | #ifndef KCMRULES | 32 | #ifndef KCMRULES | ||
33 | #include "x11client.h" | 33 | #include "x11client.h" | ||
34 | #include "client_machine.h" | 34 | #include "client_machine.h" | ||
35 | #include "screens.h" | 35 | #include "screens.h" | ||
36 | #include "workspace.h" | 36 | #include "workspace.h" | ||
37 | #endif | 37 | #endif | ||
38 | 38 | | |||
39 | #include "rulesettings.h" | ||||
40 | #include "rulebooksettings.h" | ||||
41 | | ||||
39 | namespace KWin | 42 | namespace KWin | ||
40 | { | 43 | { | ||
41 | 44 | | |||
42 | Rules::Rules() | 45 | Rules::Rules() | ||
43 | : temporary_state(0) | 46 | : temporary_state(0) | ||
44 | , wmclassmatch(UnimportantMatch) | 47 | , wmclassmatch(UnimportantMatch) | ||
45 | , wmclasscomplete(UnimportantMatch) | 48 | , wmclasscomplete(UnimportantMatch) | ||
46 | , windowrolematch(UnimportantMatch) | 49 | , windowrolematch(UnimportantMatch) | ||
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Line(s) | 92 | Rules::Rules(const QString& str, bool temporary) | |||
90 | : temporary_state(temporary ? 2 : 0) | 93 | : temporary_state(temporary ? 2 : 0) | ||
91 | { | 94 | { | ||
92 | QTemporaryFile file; | 95 | QTemporaryFile file; | ||
93 | if (file.open()) { | 96 | if (file.open()) { | ||
94 | QByteArray s = str.toUtf8(); | 97 | QByteArray s = str.toUtf8(); | ||
95 | file.write(s.data(), s.length()); | 98 | file.write(s.data(), s.length()); | ||
96 | } | 99 | } | ||
97 | file.flush(); | 100 | file.flush(); | ||
98 | KConfig cfg(file.fileName(), KConfig::SimpleConfig); | 101 | auto cfg = KSharedConfig::openConfig(file.fileName(), KConfig::SimpleConfig); | ||
99 | readFromCfg(cfg.group(QString())); | 102 | RuleSettings settings(cfg, QString()); | ||
ervin: So I guess it'll change ;-) | |||||
103 | readFromSettings(&settings); | ||||
100 | if (description.isEmpty()) | 104 | if (description.isEmpty()) | ||
101 | description = QStringLiteral("temporary"); | 105 | description = QStringLiteral("temporary"); | ||
102 | } | 106 | } | ||
103 | 107 | | |||
104 | #define READ_MATCH_STRING( var, func ) \ | 108 | #define READ_MATCH_STRING(var, func) \ | ||
105 | var = cfg.readEntry( #var ) func; \ | 109 | var = settings->var() func; \ | ||
106 | var##match = (StringMatch) qMax( FirstStringMatch, \ | 110 | var##match = static_cast<StringMatch>(settings->var##match()) | ||
107 | qMin( LastStringMatch, static_cast< StringMatch >( cfg.readEntry( #var "match",0 )))); | | |||
108 | | ||||
109 | #define READ_SET_RULE( var, func, def ) \ | | |||
110 | var = func ( cfg.readEntry( #var, def)); \ | | |||
111 | var##rule = readSetRule( cfg, QStringLiteral( #var "rule" ) ); | | |||
112 | | ||||
113 | #define READ_SET_RULE_DEF( var , func, def ) \ | | |||
114 | var = func ( cfg.readEntry( #var, def )); \ | | |||
115 | var##rule = readSetRule( cfg, QStringLiteral( #var "rule" ) ); | | |||
116 | | ||||
117 | #define READ_FORCE_RULE( var, func, def) \ | | |||
118 | var = func ( cfg.readEntry( #var, def)); \ | | |||
119 | var##rule = readForceRule( cfg, QStringLiteral( #var "rule" ) ); | | |||
120 | 111 | | |||
121 | #define READ_FORCE_RULE2( var, def, func, funcarg ) \ | 112 | #define READ_SET_RULE(var) \ | ||
122 | var = func ( cfg.readEntry( #var, def),funcarg ); \ | 113 | var = settings->var(); \ | ||
123 | var##rule = readForceRule( cfg, QStringLiteral( #var "rule" ) ); | 114 | var##rule = static_cast<SetRule>(settings->var##rule()) | ||
124 | 115 | | |||
116 | #define READ_FORCE_RULE(var, func) \ | ||||
117 | var = func(settings->var()); \ | ||||
118 | var##rule = convertForceRule(settings->var##rule()) | ||||
125 | 119 | | |||
126 | 120 | | |||
127 | Rules::Rules(const KConfigGroup& cfg) | 121 | Rules::Rules(const RuleSettings *settings) | ||
128 | : temporary_state(0) | 122 | : temporary_state(0) | ||
129 | { | 123 | { | ||
130 | readFromCfg(cfg); | 124 | readFromSettings(settings); | ||
131 | } | 125 | } | ||
132 | 126 | | |||
133 | static int limit0to4(int i) | 127 | void Rules::readFromSettings(const RuleSettings *settings) | ||
134 | { | 128 | { | ||
135 | return qMax(0, qMin(4, i)); | 129 | description = settings->description(); | ||
130 | if (description.isEmpty()) { | ||||
131 | description = settings->descriptionLegacy(); | ||||
136 | } | 132 | } | ||
137 | | ||||
138 | void Rules::readFromCfg(const KConfigGroup& cfg) | | |||
139 | { | | |||
140 | description = cfg.readEntry("Description"); | | |||
141 | if (description.isEmpty()) // capitalized first, lowercase for backwards compatibility | | |||
142 | description = cfg.readEntry("description"); | | |||
143 | READ_MATCH_STRING(wmclass, .toLower().toLatin1()); | 133 | READ_MATCH_STRING(wmclass, .toLower().toLatin1()); | ||
144 | wmclasscomplete = cfg.readEntry("wmclasscomplete" , false); | 134 | wmclasscomplete = settings->wmclasscomplete(); | ||
145 | READ_MATCH_STRING(windowrole, .toLower().toLatin1()); | 135 | READ_MATCH_STRING(windowrole, .toLower().toLatin1()); | ||
146 | READ_MATCH_STRING(title,); | 136 | READ_MATCH_STRING(title,); | ||
147 | READ_MATCH_STRING(clientmachine, .toLower().toLatin1()); | 137 | READ_MATCH_STRING(clientmachine, .toLower().toLatin1()); | ||
148 | types = NET::WindowTypeMask(cfg.readEntry<uint>("types", NET::AllTypesMask)); | 138 | types = NET::WindowTypeMask(settings->types()); | ||
149 | READ_FORCE_RULE2(placement, QString(), Placement::policyFromString, false); | 139 | READ_FORCE_RULE(placement,); | ||
150 | READ_SET_RULE_DEF(position, , invalidPoint); | 140 | READ_SET_RULE(position); | ||
151 | READ_SET_RULE(size, , QSize()); | 141 | READ_SET_RULE(size); | ||
152 | if (size.isEmpty() && sizerule != (SetRule)Remember) | 142 | if (size.isEmpty() && sizerule != static_cast<SetRule>(Remember)) | ||
153 | sizerule = UnusedSetRule; | 143 | sizerule = UnusedSetRule; | ||
154 | READ_FORCE_RULE(minsize, , QSize()); | 144 | READ_FORCE_RULE(minsize,); | ||
155 | if (!minsize.isValid()) | 145 | if (!minsize.isValid()) | ||
156 | minsize = QSize(1, 1); | 146 | minsize = QSize(1, 1); | ||
157 | READ_FORCE_RULE(maxsize, , QSize()); | 147 | READ_FORCE_RULE(maxsize,); | ||
158 | if (maxsize.isEmpty()) | 148 | if (maxsize.isEmpty()) | ||
159 | maxsize = QSize(32767, 32767); | 149 | maxsize = QSize(32767, 32767); | ||
160 | READ_FORCE_RULE(opacityactive, , 0); | 150 | READ_FORCE_RULE(opacityactive,); | ||
161 | if (opacityactive < 0 || opacityactive > 100) | 151 | READ_FORCE_RULE(opacityinactive,); | ||
162 | opacityactive = 100; | 152 | READ_SET_RULE(ignoregeometry); | ||
163 | READ_FORCE_RULE(opacityinactive, , 0); | 153 | READ_SET_RULE(desktop); | ||
164 | if (opacityinactive < 0 || opacityinactive > 100) | 154 | READ_SET_RULE(screen); | ||
165 | opacityinactive = 100; | 155 | READ_SET_RULE(activity); | ||
166 | READ_SET_RULE(ignoregeometry, , false); | 156 | READ_FORCE_RULE(type, static_cast<NET::WindowType>); | ||
167 | READ_SET_RULE(desktop, , 0); | 157 | if (type == NET::Unknown) | ||
168 | READ_SET_RULE(screen, , 0); | 158 | typerule = UnusedForceRule; | ||
169 | READ_SET_RULE(activity, , QString()); | 159 | READ_SET_RULE(maximizevert); | ||
170 | type = readType(cfg, QStringLiteral("type")); | 160 | READ_SET_RULE(maximizehoriz); | ||
171 | typerule = type != NET::Unknown ? readForceRule(cfg, QStringLiteral("typerule")) : UnusedForceRule; | 161 | READ_SET_RULE(minimize); | ||
172 | READ_SET_RULE(maximizevert, , false); | 162 | READ_SET_RULE(shade); | ||
173 | READ_SET_RULE(maximizehoriz, , false); | 163 | READ_SET_RULE(skiptaskbar); | ||
174 | READ_SET_RULE(minimize, , false); | 164 | READ_SET_RULE(skippager); | ||
175 | READ_SET_RULE(shade, , false); | 165 | READ_SET_RULE(skipswitcher); | ||
176 | READ_SET_RULE(skiptaskbar, , false); | 166 | READ_SET_RULE(above); | ||
177 | READ_SET_RULE(skippager, , false); | 167 | READ_SET_RULE(below); | ||
178 | READ_SET_RULE(skipswitcher, , false); | 168 | READ_SET_RULE(fullscreen); | ||
179 | READ_SET_RULE(above, , false); | 169 | READ_SET_RULE(noborder); | ||
180 | READ_SET_RULE(below, , false); | 170 | | ||
181 | READ_SET_RULE(fullscreen, , false); | 171 | READ_FORCE_RULE(decocolor, getDecoColor); | ||
182 | READ_SET_RULE(noborder, , false); | 172 | if (decocolor.isEmpty()) | ||
183 | decocolor = readDecoColor(cfg); | 173 | decocolorrule = UnusedForceRule; | ||
184 | decocolorrule = decocolor.isEmpty() ? UnusedForceRule : readForceRule(cfg, QStringLiteral("decocolorrule")); | 174 | | ||
185 | READ_FORCE_RULE(blockcompositing, , false); | 175 | READ_FORCE_RULE(blockcompositing,); | ||
186 | READ_FORCE_RULE(fsplevel, limit0to4, 0); // fsp is 0-4 | 176 | READ_FORCE_RULE(fsplevel,); | ||
187 | READ_FORCE_RULE(fpplevel, limit0to4, 0); // fpp is 0-4 | 177 | READ_FORCE_RULE(fpplevel,); | ||
188 | READ_FORCE_RULE(acceptfocus, , false); | 178 | READ_FORCE_RULE(acceptfocus,); | ||
189 | READ_FORCE_RULE(closeable, , false); | 179 | READ_FORCE_RULE(closeable,); | ||
190 | READ_FORCE_RULE(autogroup, , false); | 180 | READ_FORCE_RULE(autogroup,); | ||
191 | READ_FORCE_RULE(autogroupfg, , true); | 181 | READ_FORCE_RULE(autogroupfg,); | ||
192 | READ_FORCE_RULE(autogroupid, , QString()); | 182 | READ_FORCE_RULE(autogroupid,); | ||
193 | READ_FORCE_RULE(strictgeometry, , false); | 183 | READ_FORCE_RULE(strictgeometry,); | ||
194 | READ_SET_RULE(shortcut, , QString()); | 184 | READ_SET_RULE(shortcut); | ||
195 | READ_FORCE_RULE(disableglobalshortcuts, , false); | 185 | READ_FORCE_RULE(disableglobalshortcuts,); | ||
196 | READ_SET_RULE(desktopfile, , QString()); | 186 | READ_SET_RULE(desktopfile); | ||
197 | } | 187 | } | ||
198 | 188 | | |||
199 | #undef READ_MATCH_STRING | 189 | #undef READ_MATCH_STRING | ||
200 | #undef READ_SET_RULE | 190 | #undef READ_SET_RULE | ||
201 | #undef READ_FORCE_RULE | 191 | #undef READ_FORCE_RULE | ||
202 | #undef READ_FORCE_RULE2 | 192 | #undef READ_FORCE_RULE2 | ||
203 | 193 | | |||
204 | #define WRITE_MATCH_STRING( var, force ) \ | 194 | #define WRITE_MATCH_STRING(var, capital, force) \ | ||
195 | settings->set##capital##match(var##match); \ | ||||
205 | if ( !var.isEmpty() || force ) \ | 196 | if (!var.isEmpty() || force) \ | ||
206 | { \ | 197 | { \ | ||
207 | cfg.writeEntry( #var, var ); \ | 198 | settings->set##capital(var); \ | ||
208 | cfg.writeEntry( #var "match", (int)var##match ); \ | | |||
209 | } \ | | |||
210 | else \ | | |||
211 | { \ | | |||
212 | cfg.deleteEntry( #var ); \ | | |||
213 | cfg.deleteEntry( #var "match" ); \ | | |||
214 | } | 199 | } | ||
215 | 200 | | |||
216 | #define WRITE_SET_RULE( var, func ) \ | 201 | #define WRITE_SET_RULE(var, capital, func) \ | ||
202 | settings->set##capital##rule(var##rule); \ | ||||
217 | if ( var##rule != UnusedSetRule ) \ | 203 | if (var##rule != UnusedSetRule) \ | ||
218 | { \ | 204 | { \ | ||
219 | cfg.writeEntry( #var, func ( var )); \ | 205 | settings->set##capital(func(var)); \ | ||
220 | cfg.writeEntry( #var "rule", (int)var##rule ); \ | | |||
221 | } \ | | |||
222 | else \ | | |||
223 | { \ | | |||
224 | cfg.deleteEntry( #var ); \ | | |||
225 | cfg.deleteEntry( #var "rule" ); \ | | |||
226 | } | 206 | } | ||
227 | 207 | | |||
228 | #define WRITE_FORCE_RULE( var, func ) \ | 208 | #define WRITE_FORCE_RULE(var, capital, func) \ | ||
209 | settings->set##capital##rule(var##rule); \ | ||||
229 | if ( var##rule != UnusedForceRule ) \ | 210 | if ( var##rule != UnusedForceRule ) \ | ||
230 | { \ | 211 | { \ | ||
231 | cfg.writeEntry( #var, func ( var )); \ | 212 | settings->set##capital(func(var)); \ | ||
232 | cfg.writeEntry( #var "rule", (int)var##rule ); \ | | |||
233 | } \ | | |||
234 | else \ | | |||
235 | { \ | | |||
236 | cfg.deleteEntry( #var ); \ | | |||
237 | cfg.deleteEntry( #var "rule" ); \ | | |||
238 | } | 213 | } | ||
239 | 214 | | |||
240 | void Rules::write(KConfigGroup& cfg) const | 215 | void Rules::write(RuleSettings *settings) const | ||
241 | { | 216 | { | ||
242 | cfg.writeEntry("Description", description); | 217 | settings->setDescription(description); | ||
243 | // always write wmclass | 218 | // always write wmclass | ||
244 | WRITE_MATCH_STRING(wmclass, true); | 219 | WRITE_MATCH_STRING(wmclass, Wmclass, true); | ||
245 | cfg.writeEntry("wmclasscomplete", wmclasscomplete); | 220 | settings->setWmclasscomplete(wmclasscomplete); | ||
246 | WRITE_MATCH_STRING(windowrole, false); | 221 | WRITE_MATCH_STRING(windowrole, Windowrole, false); | ||
247 | WRITE_MATCH_STRING(title, false); | 222 | WRITE_MATCH_STRING(title, Title, false); | ||
248 | WRITE_MATCH_STRING(clientmachine, false); | 223 | WRITE_MATCH_STRING(clientmachine, Clientmachine, false); | ||
249 | if (types != NET::AllTypesMask) | 224 | settings->setTypes(types); | ||
250 | cfg.writeEntry("types", uint(types)); | 225 | WRITE_FORCE_RULE(placement, Placement,); | ||
251 | else | 226 | WRITE_SET_RULE(position, Position,); | ||
252 | cfg.deleteEntry("types"); | 227 | WRITE_SET_RULE(size, Size,); | ||
253 | WRITE_FORCE_RULE(placement, Placement::policyToString); | 228 | WRITE_FORCE_RULE(minsize, Minsize,); | ||
254 | WRITE_SET_RULE(position,); | 229 | WRITE_FORCE_RULE(maxsize, Maxsize,); | ||
255 | WRITE_SET_RULE(size,); | 230 | WRITE_FORCE_RULE(opacityactive, Opacityactive,); | ||
256 | WRITE_FORCE_RULE(minsize,); | 231 | WRITE_FORCE_RULE(opacityinactive, Opacityinactive,); | ||
257 | WRITE_FORCE_RULE(maxsize,); | 232 | WRITE_SET_RULE(ignoregeometry, Ignoregeometry,); | ||
258 | WRITE_FORCE_RULE(opacityactive,); | 233 | WRITE_SET_RULE(desktop, Desktop,); | ||
259 | WRITE_FORCE_RULE(opacityinactive,); | 234 | WRITE_SET_RULE(screen, Screen,); | ||
260 | WRITE_SET_RULE(ignoregeometry,); | 235 | WRITE_SET_RULE(activity, Activity,); | ||
261 | WRITE_SET_RULE(desktop,); | 236 | WRITE_FORCE_RULE(type, Type,); | ||
262 | WRITE_SET_RULE(screen,); | 237 | WRITE_SET_RULE(maximizevert, Maximizevert,); | ||
263 | WRITE_SET_RULE(activity,); | 238 | WRITE_SET_RULE(maximizehoriz, Maximizehoriz,); | ||
264 | WRITE_FORCE_RULE(type, int); | 239 | WRITE_SET_RULE(minimize, Minimize,); | ||
265 | WRITE_SET_RULE(maximizevert,); | 240 | WRITE_SET_RULE(shade, Shade,); | ||
266 | WRITE_SET_RULE(maximizehoriz,); | 241 | WRITE_SET_RULE(skiptaskbar, Skiptaskbar,); | ||
267 | WRITE_SET_RULE(minimize,); | 242 | WRITE_SET_RULE(skippager, Skippager,); | ||
268 | WRITE_SET_RULE(shade,); | 243 | WRITE_SET_RULE(skipswitcher, Skipswitcher,); | ||
269 | WRITE_SET_RULE(skiptaskbar,); | 244 | WRITE_SET_RULE(above, Above,); | ||
270 | WRITE_SET_RULE(skippager,); | 245 | WRITE_SET_RULE(below, Below,); | ||
271 | WRITE_SET_RULE(skipswitcher,); | 246 | WRITE_SET_RULE(fullscreen, Fullscreen,); | ||
272 | WRITE_SET_RULE(above,); | 247 | WRITE_SET_RULE(noborder, Noborder,); | ||
273 | WRITE_SET_RULE(below,); | | |||
274 | WRITE_SET_RULE(fullscreen,); | | |||
275 | WRITE_SET_RULE(noborder,); | | |||
276 | auto colorToString = [](const QString &value) -> QString { | 248 | auto colorToString = [](const QString &value) -> QString { | ||
277 | if (value.endsWith(QLatin1String(".colors"))) { | 249 | if (value.endsWith(QLatin1String(".colors"))) { | ||
278 | return QFileInfo(value).baseName(); | 250 | return QFileInfo(value).baseName(); | ||
279 | } else { | 251 | } else { | ||
280 | return value; | 252 | return value; | ||
281 | } | 253 | } | ||
282 | }; | 254 | }; | ||
283 | WRITE_FORCE_RULE(decocolor, colorToString); | 255 | WRITE_FORCE_RULE(decocolor, Decocolor, colorToString); | ||
284 | WRITE_FORCE_RULE(blockcompositing,); | 256 | WRITE_FORCE_RULE(blockcompositing, Blockcompositing,); | ||
285 | WRITE_FORCE_RULE(fsplevel,); | 257 | WRITE_FORCE_RULE(fsplevel, Fsplevel,); | ||
286 | WRITE_FORCE_RULE(fpplevel,); | 258 | WRITE_FORCE_RULE(fpplevel, Fpplevel,); | ||
287 | WRITE_FORCE_RULE(acceptfocus,); | 259 | WRITE_FORCE_RULE(acceptfocus, Acceptfocus,); | ||
288 | WRITE_FORCE_RULE(closeable,); | 260 | WRITE_FORCE_RULE(closeable, Closeable,); | ||
289 | WRITE_FORCE_RULE(autogroup,); | 261 | WRITE_FORCE_RULE(autogroup, Autogroup,); | ||
290 | WRITE_FORCE_RULE(autogroupfg,); | 262 | WRITE_FORCE_RULE(autogroupfg, Autogroupfg,); | ||
291 | WRITE_FORCE_RULE(autogroupid,); | 263 | WRITE_FORCE_RULE(autogroupid, Autogroupid,); | ||
292 | WRITE_FORCE_RULE(strictgeometry,); | 264 | WRITE_FORCE_RULE(strictgeometry, Strictgeometry,); | ||
293 | WRITE_SET_RULE(shortcut,); | 265 | WRITE_SET_RULE(shortcut, Shortcut,); | ||
294 | WRITE_FORCE_RULE(disableglobalshortcuts,); | 266 | WRITE_FORCE_RULE(disableglobalshortcuts, Disableglobalshortcuts,); | ||
295 | WRITE_SET_RULE(desktopfile,); | 267 | WRITE_SET_RULE(desktopfile, Desktopfile,); | ||
296 | } | 268 | } | ||
297 | 269 | | |||
298 | #undef WRITE_MATCH_STRING | 270 | #undef WRITE_MATCH_STRING | ||
299 | #undef WRITE_SET_RULE | 271 | #undef WRITE_SET_RULE | ||
300 | #undef WRITE_FORCE_RULE | 272 | #undef WRITE_FORCE_RULE | ||
301 | 273 | | |||
302 | // returns true if it doesn't affect anything | 274 | // returns true if it doesn't affect anything | ||
303 | bool Rules::isEmpty() const | 275 | bool Rules::isEmpty() const | ||
Show All 31 Lines | 277 | return(placementrule == UnusedForceRule | |||
335 | && autogroupfgrule == UnusedForceRule | 307 | && autogroupfgrule == UnusedForceRule | ||
336 | && autogroupidrule == UnusedForceRule | 308 | && autogroupidrule == UnusedForceRule | ||
337 | && strictgeometryrule == UnusedForceRule | 309 | && strictgeometryrule == UnusedForceRule | ||
338 | && shortcutrule == UnusedSetRule | 310 | && shortcutrule == UnusedSetRule | ||
339 | && disableglobalshortcutsrule == UnusedForceRule | 311 | && disableglobalshortcutsrule == UnusedForceRule | ||
340 | && desktopfilerule == UnusedSetRule); | 312 | && desktopfilerule == UnusedSetRule); | ||
341 | } | 313 | } | ||
342 | 314 | | |||
343 | Rules::SetRule Rules::readSetRule(const KConfigGroup& cfg, const QString& key) | 315 | Rules::ForceRule Rules::convertForceRule(int v) | ||
ervin: `int v`, the const is mostly useless here | |||||
We no longer read rules here. Maybe rename this method to match what it does now? zzag: We no longer read rules here. Maybe rename this method to match what it does now? | |||||
344 | { | 316 | { | ||
345 | int v = cfg.readEntry(key, 0); | | |||
346 | if (v >= DontAffect && v <= ForceTemporarily) | | |||
347 | return static_cast< SetRule >(v); | | |||
348 | return UnusedSetRule; | | |||
349 | } | | |||
350 | | ||||
351 | Rules::ForceRule Rules::readForceRule(const KConfigGroup& cfg, const QString& key) | | |||
352 | { | | |||
353 | int v = cfg.readEntry(key, 0); | | |||
354 | if (v == DontAffect || v == Force || v == ForceTemporarily) | 317 | if (v == DontAffect || v == Force || v == ForceTemporarily) | ||
355 | return static_cast< ForceRule >(v); | 318 | return static_cast<ForceRule>(v); | ||
356 | return UnusedForceRule; | 319 | return UnusedForceRule; | ||
357 | } | 320 | } | ||
358 | 321 | | |||
359 | NET::WindowType Rules::readType(const KConfigGroup& cfg, const QString& key) | 322 | QString Rules::getDecoColor(const QString &themeName) | ||
360 | { | 323 | { | ||
361 | int v = cfg.readEntry(key, 0); | | |||
362 | if (v >= NET::Normal && v <= NET::Splash) | | |||
363 | return static_cast< NET::WindowType >(v); | | |||
364 | return NET::Unknown; | | |||
365 | } | | |||
366 | | ||||
367 | QString Rules::readDecoColor(const KConfigGroup &cfg) | | |||
368 | { | | |||
369 | QString themeName = cfg.readEntry("decocolor", QString()); | | |||
370 | if (themeName.isEmpty()) { | 324 | if (themeName.isEmpty()) { | ||
371 | return QString(); | 325 | return QString(); | ||
372 | } | 326 | } | ||
373 | // find the actual scheme file | 327 | // find the actual scheme file | ||
374 | return QStandardPaths::locate(QStandardPaths::GenericDataLocation, | 328 | return QStandardPaths::locate(QStandardPaths::GenericDataLocation, | ||
375 | QLatin1String("color-schemes/") + themeName + QLatin1String(".colors")); | 329 | QLatin1String("color-schemes/") + themeName + QLatin1String(".colors")); | ||
376 | } | 330 | } | ||
377 | 331 | | |||
▲ Show 20 Lines • Show All 684 Lines • ▼ Show 20 Line(s) | |||||
1062 | void RuleBook::load() | 1016 | void RuleBook::load() | ||
1063 | { | 1017 | { | ||
1064 | deleteAll(); | 1018 | deleteAll(); | ||
1065 | if (!m_config) { | 1019 | if (!m_config) { | ||
1066 | m_config = KSharedConfig::openConfig(QStringLiteral(KWIN_NAME "rulesrc"), KConfig::NoGlobals); | 1020 | m_config = KSharedConfig::openConfig(QStringLiteral(KWIN_NAME "rulesrc"), KConfig::NoGlobals); | ||
1067 | } else { | 1021 | } else { | ||
1068 | m_config->reparseConfiguration(); | 1022 | m_config->reparseConfiguration(); | ||
1069 | } | 1023 | } | ||
1070 | int count = m_config->group("General").readEntry("count", 0); | 1024 | m_rules = RuleBookSettings(m_config).rules().toList(); | ||
1071 | for (int i = 1; | | |||
1072 | i <= count; | | |||
1073 | ++i) { | | |||
1074 | KConfigGroup cg(m_config, QString::number(i)); | | |||
1075 | Rules* rule = new Rules(cg); | | |||
1076 | m_rules.append(rule); | | |||
1077 | } | | |||
1078 | } | 1025 | } | ||
Yeah this lack of separation between General and parameterized groups really feels wrong ervin: Yeah this lack of separation between General and parameterized groups really feels wrong | |||||
ervin: I wonder if that would still make sense if we got a getter for the list. | |||||
1079 | 1026 | | |||
ervin: Space before * not after | |||||
1080 | void RuleBook::save() | 1027 | void RuleBook::save() | ||
1081 | { | 1028 | { | ||
1082 | m_updateTimer->stop(); | 1029 | m_updateTimer->stop(); | ||
1083 | if (!m_config) { | 1030 | if (!m_config) { | ||
1084 | qCWarning(KWIN_CORE) << "RuleBook::save invoked without prior invocation of RuleBook::load"; | 1031 | qCWarning(KWIN_CORE) << "RuleBook::save invoked without prior invocation of RuleBook::load"; | ||
1085 | return; | 1032 | return; | ||
1086 | } | 1033 | } | ||
1087 | QStringList groups = m_config->groupList(); | 1034 | QVector<Rules *> filteredRules; | ||
ervin: declare groups as const or wrap it in qAsConst here | |||||
1088 | for (QStringList::ConstIterator it = groups.constBegin(); | 1035 | for (const auto &rule : qAsConst(m_rules)) { | ||
ervin: `qAsConst(m_rules)` | |||||
1089 | it != groups.constEnd(); | 1036 | if (!rule->isTemporary()) { | ||
1090 | ++it) | 1037 | filteredRules.append(rule); | ||
1091 | m_config->deleteGroup(*it); | 1038 | } | ||
1092 | m_config->group("General").writeEntry("count", m_rules.count()); | | |||
1093 | int i = 1; | | |||
1094 | for (QList< Rules* >::ConstIterator it = m_rules.constBegin(); | | |||
1095 | it != m_rules.constEnd(); | | |||
1096 | ++it) { | | |||
1097 | if ((*it)->isTemporary()) | | |||
1098 | continue; | | |||
1099 | KConfigGroup cg(m_config, QString::number(i)); | | |||
1100 | (*it)->write(cg); | | |||
1101 | ++i; | | |||
1102 | } | 1039 | } | ||
1103 | m_config->sync(); | 1040 | RuleBookSettings settings(m_config); | ||
1041 | settings.setRules(filteredRules); | ||||
1042 | settings.save(); | ||||
1104 | } | 1043 | } | ||
1105 | 1044 | | |||
1106 | void RuleBook::temporaryRulesMessage(const QString& message) | 1045 | void RuleBook::temporaryRulesMessage(const QString& message) | ||
1107 | { | 1046 | { | ||
1108 | bool was_temporary = false; | 1047 | bool was_temporary = false; | ||
1109 | for (QList< Rules* >::ConstIterator it = m_rules.constBegin(); | 1048 | for (QList< Rules* >::ConstIterator it = m_rules.constBegin(); | ||
1110 | it != m_rules.constEnd(); | 1049 | it != m_rules.constEnd(); | ||
1111 | ++it) | 1050 | ++it) | ||
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines |
So I guess it'll change ;-)