Changeset View
Changeset View
Standalone View
Standalone View
applets/kicker/plugin/systementry.cpp
Show All 13 Lines | |||||
14 | * You should have received a copy of the GNU General Public License * | 14 | * You should have received a copy of the GNU General Public License * | ||
15 | * along with this program; if not, write to the * | 15 | * along with this program; if not, write to the * | ||
16 | * Free Software Foundation, Inc., * | 16 | * Free Software Foundation, Inc., * | ||
17 | * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA . * | 17 | * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA . * | ||
18 | ***************************************************************************/ | 18 | ***************************************************************************/ | ||
19 | 19 | | |||
20 | #include "systementry.h" | 20 | #include "systementry.h" | ||
21 | 21 | | |||
22 | #include <QDBusConnection> | | |||
23 | #include <QDBusInterface> | | |||
24 | #include <QDBusPendingCall> | | |||
25 | | ||||
26 | #include <KAuthorized> | | |||
27 | #include <KConfigGroup> | | |||
28 | #include <KLocalizedString> | 22 | #include <KLocalizedString> | ||
29 | #include <KSharedConfig> | | |||
30 | #include <kworkspace.h> | | |||
31 | #include <Solid/PowerManagement> | | |||
32 | #include "ksmserver_interface.h" | | |||
33 | #include <kworkspace5/kdisplaymanager.h> | | |||
34 | 23 | | |||
35 | SystemEntry::SystemEntry(AbstractModel *owner, Action action) : AbstractEntry(owner) | 24 | #include "sessionmanagement.h" | ||
25 | | ||||
26 | int SystemEntry::s_instanceCount = 0; | ||||
broulik: QSharedPointer :P | |||||
Personally I tend to prefer just readable, explicit code for simple cases. hein: Personally I tend to prefer just readable, explicit code for simple cases. | |||||
27 | SessionManagement* SystemEntry::s_sessionManagement = nullptr; | ||||
28 | | ||||
29 | SystemEntry::SystemEntry(AbstractModel *owner, Action action) | ||||
30 | : QObject() | ||||
31 | , AbstractEntry(owner) | ||||
32 | , m_initialized(false) | ||||
36 | , m_action(action) | 33 | , m_action(action) | ||
37 | , m_valid(false) | 34 | , m_valid(false) | ||
38 | { | 35 | { | ||
39 | init(); | 36 | refresh(); | ||
37 | ++s_instanceCount; | ||||
38 | m_initialized = true; | ||||
40 | } | 39 | } | ||
41 | 40 | | |||
42 | SystemEntry::SystemEntry(AbstractModel *owner, const QString &id) : AbstractEntry(owner) | 41 | SystemEntry::SystemEntry(AbstractModel *owner, const QString &id) | ||
42 | : QObject() | ||||
43 | , AbstractEntry(owner) | ||||
44 | , m_initialized(false) | ||||
43 | , m_action(NoAction) | 45 | , m_action(NoAction) | ||
44 | , m_valid(false) | 46 | , m_valid(false) | ||
45 | { | 47 | { | ||
46 | if (id == QLatin1String("lock-screen")) { | 48 | if (id == QLatin1String("lock-screen")) { | ||
47 | m_action = LockSession; | 49 | m_action = LockSession; | ||
48 | } else if (id == QLatin1String("logout")) { | 50 | } else if (id == QLatin1String("logout")) { | ||
49 | m_action = LogoutSession; | 51 | m_action = LogoutSession; | ||
50 | } else if (id == QLatin1String("save-session")) { | 52 | } else if (id == QLatin1String("save-session")) { | ||
51 | m_action = SaveSession; | 53 | m_action = SaveSession; | ||
52 | } else if (id == QLatin1String("switch-user")) { | 54 | } else if (id == QLatin1String("switch-user")) { | ||
53 | m_action = SwitchUser; | 55 | m_action = SwitchUser; | ||
54 | } else if (id == QLatin1String("suspend")) { | 56 | } else if (id == QLatin1String("suspend")) { | ||
55 | m_action = SuspendToRam; | 57 | m_action = Suspend; | ||
56 | } else if (id == QLatin1String("hibernate")) { | 58 | } else if (id == QLatin1String("hibernate")) { | ||
57 | m_action = SuspendToDisk; | 59 | m_action = Hibernate; | ||
58 | } else if (id == QLatin1String("reboot")) { | 60 | } else if (id == QLatin1String("reboot")) { | ||
59 | m_action = Reboot; | 61 | m_action = Reboot; | ||
60 | } else if (id == QLatin1String("shutdown")) { | 62 | } else if (id == QLatin1String("shutdown")) { | ||
61 | m_action = Shutdown; | 63 | m_action = Shutdown; | ||
62 | } | 64 | } | ||
63 | 65 | | |||
64 | init(); | 66 | refresh(); | ||
67 | ++s_instanceCount; | ||||
68 | m_initialized = true; | ||||
65 | } | 69 | } | ||
66 | 70 | | |||
67 | void SystemEntry::init() | 71 | SystemEntry::~SystemEntry() | ||
68 | { | 72 | { | ||
69 | switch (m_action) { | 73 | --s_instanceCount; | ||
70 | case NoAction: | | |||
71 | m_valid = false; | | |||
72 | break; | | |||
73 | case LockSession: | | |||
74 | m_valid = KAuthorized::authorizeAction(QStringLiteral("lock_screen")); | | |||
75 | break; | | |||
76 | case LogoutSession: | | |||
77 | case SaveSession: | | |||
78 | { | | |||
79 | bool authorize = KAuthorized::authorizeAction(QStringLiteral("logout")) && KAuthorized::authorize(QStringLiteral("logout")); | | |||
80 | 74 | | |||
81 | if (m_action == SaveSession) { | 75 | if (!s_instanceCount) { | ||
82 | const KConfigGroup c(KSharedConfig::openConfig(QStringLiteral("ksmserverrc"), KConfig::NoGlobals), "General"); | 76 | delete s_sessionManagement; | ||
77 | s_sessionManagement = nullptr; | ||||
78 | } | ||||
79 | } | ||||
80 | | ||||
81 | SystemEntry::Action SystemEntry::action() const | ||||
82 | { | ||||
83 | return m_action; | ||||
84 | } | ||||
83 | 85 | | |||
84 | m_valid = authorize && c.readEntry("loginMode") == QLatin1String("restoreSavedSession"); | 86 | void SystemEntry::refresh() | ||
85 | } else { | 87 | { | ||
86 | m_valid = authorize; | 88 | if (!s_sessionManagement) { | ||
you increment this on every refresh, only decrement once in the destructor refresh is potentially called multiple times in the object's lifespan refresh is called from the constructor so we may as well do it all there davidedmundson: you increment this on every refresh, only decrement once in the destructor
refresh is… | |||||
89 | s_sessionManagement = new SessionManagement(); | ||||
87 | } | 90 | } | ||
88 | 91 | | |||
92 | bool valid = false; | ||||
93 | | ||||
94 | switch (m_action) { | ||||
95 | case LockSession: { | ||||
96 | valid = s_sessionManagement->canLock(); | ||||
97 | QObject::connect(s_sessionManagement, &SessionManagement::canLockChanged, | ||||
98 | this, &SystemEntry::refresh); | ||||
89 | break; | 99 | break; | ||
90 | } | 100 | } | ||
91 | case SwitchUser: | 101 | case LogoutSession: { | ||
92 | m_valid = (KAuthorized::authorizeAction(QStringLiteral("start_new_session")) || KAuthorized::authorizeAction(QStringLiteral("switch_user"))) | 102 | valid = s_sessionManagement->canLogout(); | ||
93 | && KDisplayManager().isSwitchable(); | 103 | QObject::connect(s_sessionManagement, &SessionManagement::canLogoutChanged, | ||
104 | this, &SystemEntry::refresh); | ||||
94 | break; | 105 | break; | ||
95 | case SuspendToRam: | 106 | } | ||
96 | m_valid = Solid::PowerManagement::supportedSleepStates().contains(Solid::PowerManagement::SuspendState); | 107 | case SaveSession: { | ||
108 | valid = s_sessionManagement->canSaveSession(); | ||||
109 | QObject::connect(s_sessionManagement, &SessionManagement::canSaveSessionChanged, | ||||
110 | this, &SystemEntry::refresh); | ||||
97 | break; | 111 | break; | ||
98 | case SuspendToDisk: | 112 | } | ||
99 | m_valid = Solid::PowerManagement::supportedSleepStates().contains(Solid::PowerManagement::HibernateState); | 113 | case SwitchUser: { | ||
114 | valid = s_sessionManagement->canSwitchUser(); | ||||
115 | QObject::connect(s_sessionManagement, &SessionManagement::canSwitchUserChanged, | ||||
116 | this, &SystemEntry::refresh); | ||||
100 | break; | 117 | break; | ||
101 | case Reboot: | 118 | } | ||
102 | m_valid = KWorkSpace::canShutDown(KWorkSpace::ShutdownConfirmDefault, KWorkSpace::ShutdownTypeReboot); | 119 | case Suspend: { | ||
120 | valid = s_sessionManagement->canSuspend(); | ||||
121 | QObject::connect(s_sessionManagement, &SessionManagement::canSuspendChanged, | ||||
122 | this, &SystemEntry::refresh); | ||||
103 | break; | 123 | break; | ||
104 | case Shutdown: | 124 | } | ||
105 | m_valid = KWorkSpace::canShutDown(KWorkSpace::ShutdownConfirmDefault, KWorkSpace::ShutdownTypeHalt); | 125 | case Hibernate: { | ||
126 | valid = s_sessionManagement->canHibernate(); | ||||
127 | QObject::connect(s_sessionManagement, &SessionManagement::canHibernateChanged, | ||||
128 | this, &SystemEntry::refresh); | ||||
129 | break; | ||||
130 | } | ||||
131 | case Reboot: { | ||||
132 | valid = s_sessionManagement->canReboot(); | ||||
133 | QObject::connect(s_sessionManagement, &SessionManagement::canRebootChanged, | ||||
134 | this, &SystemEntry::refresh); | ||||
106 | break; | 135 | break; | ||
136 | } | ||||
137 | case Shutdown: { | ||||
138 | valid = s_sessionManagement->canShutdown(); | ||||
139 | QObject::connect(s_sessionManagement, &SessionManagement::canShutdownChanged, | ||||
140 | this, &SystemEntry::refresh); | ||||
141 | break; | ||||
142 | } | ||||
107 | default: | 143 | default: | ||
108 | m_valid = true; | 144 | break; | ||
145 | } | ||||
146 | | ||||
147 | | ||||
148 | if (m_valid != valid) { | ||||
149 | m_valid = valid; | ||||
150 | | ||||
151 | if (m_initialized) { | ||||
152 | emit isValidChanged(); | ||||
153 | } | ||||
109 | } | 154 | } | ||
110 | } | 155 | } | ||
111 | 156 | | |||
112 | bool SystemEntry::isValid() const | 157 | bool SystemEntry::isValid() const | ||
113 | { | 158 | { | ||
114 | return m_valid; | 159 | return m_valid; | ||
115 | } | 160 | } | ||
116 | 161 | | |||
Show All 18 Lines | 179 | case LogoutSession: | |||
135 | return QStringLiteral("system-log-out"); | 180 | return QStringLiteral("system-log-out"); | ||
136 | break; | 181 | break; | ||
137 | case SaveSession: | 182 | case SaveSession: | ||
138 | return QStringLiteral("system-save-session"); | 183 | return QStringLiteral("system-save-session"); | ||
139 | break; | 184 | break; | ||
140 | case SwitchUser: | 185 | case SwitchUser: | ||
141 | return QStringLiteral("system-switch-user"); | 186 | return QStringLiteral("system-switch-user"); | ||
142 | break; | 187 | break; | ||
143 | case SuspendToRam: | 188 | case Suspend: | ||
144 | return QStringLiteral("system-suspend"); | 189 | return QStringLiteral("system-suspend"); | ||
145 | break; | 190 | break; | ||
146 | case SuspendToDisk: | 191 | case Hibernate: | ||
147 | return QStringLiteral("system-suspend-hibernate"); | 192 | return QStringLiteral("system-suspend-hibernate"); | ||
148 | break; | 193 | break; | ||
149 | case Reboot: | 194 | case Reboot: | ||
150 | return QStringLiteral("system-reboot"); | 195 | return QStringLiteral("system-reboot"); | ||
151 | break; | 196 | break; | ||
152 | case Shutdown: | 197 | case Shutdown: | ||
153 | return QStringLiteral("system-shutdown"); | 198 | return QStringLiteral("system-shutdown"); | ||
154 | break; | 199 | break; | ||
Show All 14 Lines | 213 | case LogoutSession: | |||
169 | return i18n("Log Out"); | 214 | return i18n("Log Out"); | ||
170 | break; | 215 | break; | ||
171 | case SaveSession: | 216 | case SaveSession: | ||
172 | return i18n("Save Session"); | 217 | return i18n("Save Session"); | ||
173 | break; | 218 | break; | ||
174 | case SwitchUser: | 219 | case SwitchUser: | ||
175 | return i18n("Switch User"); | 220 | return i18n("Switch User"); | ||
176 | break; | 221 | break; | ||
177 | case SuspendToRam: | 222 | case Suspend: | ||
178 | return i18nc("Suspend to RAM", "Sleep"); | 223 | return i18nc("Suspend to RAM", "Sleep"); | ||
179 | break; | 224 | break; | ||
180 | case SuspendToDisk: | 225 | case Hibernate: | ||
181 | return i18n("Hibernate"); | 226 | return i18n("Hibernate"); | ||
182 | break; | 227 | break; | ||
183 | case Reboot: | 228 | case Reboot: | ||
184 | return i18n("Restart"); | 229 | return i18n("Restart"); | ||
185 | break; | 230 | break; | ||
186 | case Shutdown: | 231 | case Shutdown: | ||
187 | return i18n("Shut Down"); | 232 | return i18n("Shut Down"); | ||
188 | break; | 233 | break; | ||
Show All 14 Lines | 247 | case LogoutSession: | |||
203 | return i18n("Session"); | 248 | return i18n("Session"); | ||
204 | break; | 249 | break; | ||
205 | case SaveSession: | 250 | case SaveSession: | ||
206 | return i18n("Session"); | 251 | return i18n("Session"); | ||
207 | break; | 252 | break; | ||
208 | case SwitchUser: | 253 | case SwitchUser: | ||
209 | return i18n("Session"); | 254 | return i18n("Session"); | ||
210 | break; | 255 | break; | ||
211 | case SuspendToRam: | 256 | case Suspend: | ||
212 | return i18n("System"); | 257 | return i18n("System"); | ||
213 | break; | 258 | break; | ||
214 | case SuspendToDisk: | 259 | case Hibernate: | ||
215 | return i18n("System"); | 260 | return i18n("System"); | ||
216 | break; | 261 | break; | ||
217 | case Reboot: | 262 | case Reboot: | ||
218 | return i18n("System"); | 263 | return i18n("System"); | ||
219 | break; | 264 | break; | ||
220 | case Shutdown: | 265 | case Shutdown: | ||
221 | return i18n("System"); | 266 | return i18n("System"); | ||
222 | break; | 267 | break; | ||
Show All 14 Lines | 281 | case LogoutSession: | |||
237 | return i18n("End session"); | 282 | return i18n("End session"); | ||
238 | break; | 283 | break; | ||
239 | case SaveSession: | 284 | case SaveSession: | ||
240 | return i18n("Save Session"); | 285 | return i18n("Save Session"); | ||
241 | break; | 286 | break; | ||
242 | case SwitchUser: | 287 | case SwitchUser: | ||
243 | return i18n("Start a parallel session as a different user"); | 288 | return i18n("Start a parallel session as a different user"); | ||
244 | break; | 289 | break; | ||
245 | case SuspendToRam: | 290 | case Suspend: | ||
246 | return i18n("Suspend to RAM"); | 291 | return i18n("Suspend to RAM"); | ||
247 | break; | 292 | break; | ||
248 | case SuspendToDisk: | 293 | case Hibernate: | ||
249 | return i18n("Suspend to disk"); | 294 | return i18n("Suspend to disk"); | ||
250 | break; | 295 | break; | ||
251 | case Reboot: | 296 | case Reboot: | ||
252 | return i18n("Restart computer"); | 297 | return i18n("Restart computer"); | ||
253 | break; | 298 | break; | ||
254 | case Shutdown: | 299 | case Shutdown: | ||
255 | return i18n("Turn off computer"); | 300 | return i18n("Turn off computer"); | ||
256 | break; | 301 | break; | ||
Show All 14 Lines | 315 | case LogoutSession: | |||
271 | return QStringLiteral("logout"); | 316 | return QStringLiteral("logout"); | ||
272 | break; | 317 | break; | ||
273 | case SaveSession: | 318 | case SaveSession: | ||
274 | return QStringLiteral("save-session"); | 319 | return QStringLiteral("save-session"); | ||
275 | break; | 320 | break; | ||
276 | case SwitchUser: | 321 | case SwitchUser: | ||
277 | return QStringLiteral("switch-user"); | 322 | return QStringLiteral("switch-user"); | ||
278 | break; | 323 | break; | ||
279 | case SuspendToRam: | 324 | case Suspend: | ||
280 | return QStringLiteral("suspend"); | 325 | return QStringLiteral("suspend"); | ||
281 | break; | 326 | break; | ||
282 | case SuspendToDisk: | 327 | case Hibernate: | ||
283 | return QStringLiteral("hibernate"); | 328 | return QStringLiteral("hibernate"); | ||
284 | break; | 329 | break; | ||
285 | case Reboot: | 330 | case Reboot: | ||
286 | return QStringLiteral("reboot"); | 331 | return QStringLiteral("reboot"); | ||
287 | break; | 332 | break; | ||
288 | case Shutdown: | 333 | case Shutdown: | ||
289 | return QStringLiteral("shutdown"); | 334 | return QStringLiteral("shutdown"); | ||
290 | break; | 335 | break; | ||
291 | 336 | | |||
292 | default: | 337 | default: | ||
293 | break; | 338 | break; | ||
294 | } | 339 | } | ||
295 | 340 | | |||
296 | return QString(); | 341 | return QString(); | ||
297 | } | 342 | } | ||
298 | 343 | | |||
299 | bool SystemEntry::run(const QString& actionId, const QVariant &argument) | 344 | bool SystemEntry::run(const QString& actionId, const QVariant &argument) | ||
300 | { | 345 | { | ||
301 | Q_UNUSED(actionId) | 346 | Q_UNUSED(actionId) | ||
302 | Q_UNUSED(argument) | 347 | Q_UNUSED(argument) | ||
303 | 348 | | |||
304 | switch (m_action) { | 349 | if (!m_valid) { | ||
305 | case LockSession: | 350 | return false; | ||
306 | { | | |||
307 | QDBusConnection bus = QDBusConnection::sessionBus(); | | |||
308 | QDBusInterface interface(QStringLiteral("org.freedesktop.ScreenSaver"), QStringLiteral("/ScreenSaver"), QStringLiteral("org.freedesktop.ScreenSaver"), bus); | | |||
309 | interface.asyncCall(QStringLiteral("Lock")); | | |||
310 | break; | | |||
311 | } | | |||
312 | case LogoutSession: | | |||
313 | KWorkSpace::requestShutDown(KWorkSpace::ShutdownConfirmDefault, KWorkSpace::ShutdownTypeNone); | | |||
314 | break; | | |||
315 | case SaveSession: | | |||
316 | { | | |||
317 | org::kde::KSMServerInterface ksmserver(QStringLiteral("org.kde.ksmserver"), | | |||
318 | QStringLiteral("/KSMServer"), QDBusConnection::sessionBus()); | | |||
319 | | ||||
320 | if (ksmserver.isValid()) { | | |||
321 | ksmserver.saveCurrentSession(); | | |||
322 | } | 351 | } | ||
323 | 352 | | |||
324 | break; | 353 | switch (m_action) { | ||
325 | } | 354 | case LockSession: s_sessionManagement->lock(); break; | ||
326 | case SwitchUser: | 355 | case LogoutSession: s_sessionManagement->requestLogout(); break; | ||
327 | { | 356 | case SaveSession: s_sessionManagement->saveSession(); break; | ||
328 | QDBusConnection bus = QDBusConnection::sessionBus(); | 357 | case SwitchUser: s_sessionManagement->switchUser(); break; | ||
329 | QDBusInterface interface(QStringLiteral("org.kde.ksmserver"), QStringLiteral("/KSMServer"), QStringLiteral("org.kde.KSMServerInterface"), bus); | 358 | case Suspend: s_sessionManagement->suspend(); break; | ||
330 | interface.asyncCall(QStringLiteral("openSwitchUserDialog")); | 359 | case Hibernate: s_sessionManagement->hibernate(); break; | ||
331 | break; | 360 | case Reboot: s_sessionManagement->requestReboot(); break; | ||
332 | }; | 361 | case Shutdown: s_sessionManagement->requestShutdown(); break; | ||
333 | case SuspendToRam: | 362 | default: break; | ||
334 | Solid::PowerManagement::requestSleep(Solid::PowerManagement::SuspendState, nullptr, nullptr); | | |||
335 | break; | | |||
336 | case SuspendToDisk: | | |||
337 | Solid::PowerManagement::requestSleep(Solid::PowerManagement::HibernateState, nullptr, nullptr); | | |||
338 | break; | | |||
339 | case Reboot: | | |||
340 | KWorkSpace::requestShutDown(KWorkSpace::ShutdownConfirmDefault, KWorkSpace::ShutdownTypeReboot); | | |||
341 | break; | | |||
342 | case Shutdown: | | |||
343 | KWorkSpace::requestShutDown(KWorkSpace::ShutdownConfirmDefault, KWorkSpace::ShutdownTypeHalt); | | |||
344 | break; | | |||
345 | default: | | |||
346 | return false; | | |||
347 | } | 363 | } | ||
348 | 364 | | |||
349 | return true; | 365 | return true; | ||
350 | } | 366 | } |
QSharedPointer :P