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