Differential D20237 Diff 55440 applets/kicker/plugin/systementry.cpp

Changeset View

Standalone View

View Options

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​
35SystemEntry::SystemEntry(AbstractModel *owner, Action action) : AbstractEntry(owner) 24​#include "sessionmanagement.h"
25​
26​int SystemEntry::s_instanceCount = 0;
broulikUnsubmitted
Not Done

QSharedPointer :P

broulik: QSharedPointer :P
heinAuthorUnsubmitted
Not Done

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​ m_initialized = true;
40} 38​}
41 39​
42SystemEntry::SystemEntry(AbstractModel *owner, const QString &id) : AbstractEntry(owner) 40​SystemEntry::SystemEntry(AbstractModel *owner, const QString &id)
41​ : QObject()
42​ , AbstractEntry(owner)
43​ , m_initialized(false)
43, m_action(NoAction) 44​ , m_action(NoAction)
44, m_valid(false) 45​ , m_valid(false)
45{ 46​{
46 if (id == QLatin1String("lock-screen")) { 47​ if (id == QLatin1String("lock-screen")) {
47 m_action = LockSession; 48​ m_action = LockSession;
48 } else if (id == QLatin1String("logout")) { 49​ } else if (id == QLatin1String("logout")) {
49 m_action = LogoutSession; 50​ m_action = LogoutSession;
50 } else if (id == QLatin1String("save-session")) { 51​ } else if (id == QLatin1String("save-session")) {
51 m_action = SaveSession; 52​ m_action = SaveSession;
52 } else if (id == QLatin1String("switch-user")) { 53​ } else if (id == QLatin1String("switch-user")) {
53 m_action = SwitchUser; 54​ m_action = SwitchUser;
54 } else if (id == QLatin1String("suspend")) { 55​ } else if (id == QLatin1String("suspend")) {
55 m_action = SuspendToRam; 56​ m_action = Suspend;
56 } else if (id == QLatin1String("hibernate")) { 57​ } else if (id == QLatin1String("hibernate")) {
57 m_action = SuspendToDisk; 58​ m_action = Hibernate;
58 } else if (id == QLatin1String("reboot")) { 59​ } else if (id == QLatin1String("reboot")) {
59 m_action = Reboot; 60​ m_action = Reboot;
60 } else if (id == QLatin1String("shutdown")) { 61​ } else if (id == QLatin1String("shutdown")) {
61 m_action = Shutdown; 62​ m_action = Shutdown;
62 } 63​ }
63 64​
64 init(); 65​ refresh();
66​ m_initialized = true;
65} 67​}
66 68​
67void SystemEntry::init() 69​SystemEntry::~SystemEntry()
68{ 70​{
69 switch (m_action) { 71​ --s_instanceCount;
70 case NoAction: 72​
71 m_valid = false; 73​ if (!s_instanceCount) {
72 break; 74​ delete s_sessionManagement;
73 case LockSession: 75​ s_sessionManagement = nullptr;
74 m_valid = KAuthorized::authorizeAction(QStringLiteral("lock_screen")); 76​ }
75 break; 77​}
76 case LogoutSession: 78​
77 case SaveSession: 79​SystemEntry::Action SystemEntry::action() const
78 { 80​{
79 bool authorize = KAuthorized::authorizeAction(QStringLiteral("logout")) && KAuthorized::authorize(QStringLiteral("logout")); 81​ return m_action;
82​}
80 83​
81 if (m_action == SaveSession) { 84​void SystemEntry::refresh()
82 const KConfigGroup c(KSharedConfig::openConfig(QStringLiteral("ksmserverrc"), KConfig::NoGlobals), "General"); 85​{
86​ ++s_instanceCount;
davidedmundsonUnsubmitted
Not Done

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…
83 87​
84 m_valid = authorize && c.readEntry("loginMode") == QLatin1String("restoreSavedSession"); 88​ if (!s_sessionManagement) {
85 } else { 89​ s_sessionManagement = new SessionManagement();
86 m_valid = authorize; ​
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​
112bool 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 Lines179 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 Lines213 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 Lines247 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 Lines281 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 Lines315 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​
299bool 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​}