Differential D21725 Diff 59529 startkde/startplasma.cpp

Changeset View

Standalone View

View Options

startkde/startplasma.cpp

  • This file was added.
1​/* This file is part of the KDE project
2​ Copyright (C) 2019 Aleix Pol Gonzalez <aleixpol@kde.org>
3​
4​ This library is free software; you can redistribute it and/or
5​ modify it under the terms of the GNU Library General Public
6​ License as published by the Free Software Foundation; either
7​ version 2 of the License, or (at your option) any later version.
8​
9​ This library is distributed in the hope that it will be useful,
10​ but WITHOUT ANY WARRANTY; without even the implied warranty of
11​ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12​ Library General Public License for more details.
13​
14​ You should have received a copy of the GNU Library General Public License
15​ along with this library; see the file COPYING.LIB. If not, write to
16​ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17​ Boston, MA 02110-1301, USA.
18​*/
19​
20​#include <QDir>
21​#include <QProcess>
22​#include <QStandardPaths>
23​#include <QTextStream>
24​#include <QDBusConnectionInterface>
25​#include <KConfig>
26​#include <KConfigGroup>
27​
28​#include <unistd.h>
29​
30​#include "startplasma.h"
31​
32​QTextStream out(stderr);
33​
34​void messageBox(const QString &text)
35​{
davidedmundsonUnsubmitted
Not Done

old code killed ksplash when we showed a message

davidedmundson: old code killed ksplash when we showed a message
apolAuthorUnsubmitted
Not Done

Now we will return, which will get KSplash out of scope and kill the process upon destruction. See KillBeforeDeleter.

apol: Now we will return, which will get KSplash out of scope and kill the process upon destruction.
36​ out << text;
37​ runSync(QStringLiteral("xmessage"), {QStringLiteral("-geometry"), QStringLiteral("500x100"), text});
38​}
39​
40​QStringList allServices(const QLatin1String& prefix)
41​{
42​ QDBusConnectionInterface *bus = QDBusConnection::sessionBus().interface();
43​ const QStringList services = bus->registeredServiceNames();
44​ QMap<QString, QStringList> servicesWithAliases;
45​
46​ for (const QString &serviceName : services) {
47​ QDBusReply<QString> reply = bus->serviceOwner(serviceName);
48​ QString owner = reply;
49​ if (owner.isEmpty())
50​ owner = serviceName;
51​ servicesWithAliases[owner].append(serviceName);
52​ }
53​
54​ QStringList names;
55​ for (auto it = servicesWithAliases.constBegin(); it != servicesWithAliases.constEnd(); ++it) {
56​ if (it.value().startsWith(prefix))
57​ names << it.value();
58​ }
59​ names.removeDuplicates();
60​ names.sort();
61​ return names;
62​}
63​
64​int runSync(const QString& program, const QStringList &args, const QStringList &env)
65​{
66​ QProcess p;
67​ if (!env.isEmpty())
68​ p.setEnvironment(QProcess::systemEnvironment() << env);
69​ p.setProcessChannelMode(QProcess::ForwardedChannels);
70​ p.start(program, args);
71​// qDebug() << "started..." << program << args;
72​ p.waitForFinished(-1);
73​ if (p.exitCode()) {
74​ qWarning() << program << args << "exited with code" << p.exitCode();
75​ }
76​ return p.exitCode();
77​}
78​
79​void sourceFiles(const QStringList &files)
80​{
81​ QStringList filteredFiles;
82​ std::copy_if(files.begin(), files.end(), std::back_inserter(filteredFiles), [](const QString& i){ return QFileInfo(i).isReadable(); } );
broulikUnsubmitted
Not Done

Should we also check for executable permission?

broulik: Should we also check for executable permission?
apolAuthorUnsubmitted
Not Done

We don't now and it's not required. I'd aim at not changes in behaviour.

apol: We don't now and it's not required. I'd aim at not changes in behaviour.
83​
84​ if (filteredFiles.isEmpty())
85​ return;
86​
87​ filteredFiles.prepend(QStringLiteral(CMAKE_INSTALL_FULL_LIBEXECDIR "/plasma-sourceenv.sh"));
88​
89​ QProcess p;
90​ p.start(QStringLiteral("/bin/sh"), filteredFiles);
91​ p.waitForFinished(-1);
92​
93​ const auto fullEnv = p.readAllStandardOutput();
94​ auto envs = fullEnv.split('\n');
95​
96​ for (auto &env: envs) {
97​ if (env.startsWith("_=") || env.startsWith("SHLVL"))
98​ continue;
99​
100​ const int idx = env.indexOf('=');
101​ if (Q_UNLIKELY(idx <= 0))
102​ continue;
103​
104​ if (qgetenv(env.left(idx)) != env.mid(idx+1)) {
105​// qDebug() << "setting..." << env.left(idx) << env.mid(idx+1) << "was" << qgetenv(env.left(idx));
106​ qputenv(env.left(idx), env.mid(idx+1));
107​ }
108​ }
109​}
110​
111​void createConfigDirectory()
112​{
113​ const QString configDir = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
114​ if (!QDir().mkpath(configDir))
115​ out << "Could not create config directory XDG_CONFIG_HOME: " << configDir << '\n';
116​}
117​
118​void runStartupConfig()
119​{
120​ const QString configDir = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
121​
122​ const QString localerc(configDir + QLatin1String("/plasma-localerc"));
123​ if (!QFile::exists(localerc)) {
124​ QFile f(localerc);
davidedmundsonUnsubmitted
Not Done

Not a blocker, but why not use KConfig here?

davidedmundson: Not a blocker, but why not use KConfig here?
apolAuthorUnsubmitted
Not Done

Because this is clearly faster and not complex at all to read. I can change it if you like.
This way we don't worry about reading global files and such.

apol: Because this is clearly faster and not complex at all to read. I can change it if you like.
125​ f.open(QFile::WriteOnly);
126​ f.write("[Formats]\n"
127​ "LANG=" + qgetenv("LANG") + '\n');
128​ }
129​
130​ //export LC_* variables set by kcmshell5 formats into environment
131​ //so it can be picked up by QLocale and friends.
132​ sourceFiles({configDir + QStringLiteral("/plasma-locale-settings.sh")});
133​}
134​
135​void setupCursor(bool wayland)
136​{
137​ const KConfig cfg(QStringLiteral("kcminputrc"));
138​ const KConfigGroup inputCfg = cfg.group("Mouse");
139​
140​ const auto kcminputrc_mouse_cursorsize = inputCfg.readEntry("cursorSize", QString());
141​ const auto kcminputrc_mouse_cursortheme = inputCfg.readEntry("cursorTheme", QStringLiteral("breeze_cursors"));
142​ if (!kcminputrc_mouse_cursortheme.isEmpty() || !kcminputrc_mouse_cursorsize.isEmpty()) {
143​#ifdef XCURSOR_PATH
davidedmundsonUnsubmitted
Not Done

Don't yet.

This being here is (I think) the result of a lazy hack due to env vars not getting synced properly from kcminit. I hope to address that.

Obviously your port being a 1:1 clone is fine.

davidedmundson: Don't yet. This being here is (I think) the result of a lazy hack due to env vars not getting…
apolAuthorUnsubmitted
Not Done

I won't, yet.

apol: I won't, yet.
144​ QByteArray path(XCURSOR_PATH);
145​ path.replace("$XCURSOR_PATH", qgetenv("XCURSOR_PATH"));
146​ qputenv("XCURSOR_PATH", path);
147​#endif
148​ }
149​
150​ //TODO: consider linking directly
151​ const int applyMouseStatus = wayland ? 0 : runSync(QStringLiteral("kapplymousetheme"), { QStringLiteral("kcminputrc_mouse_cursortheme"), QStringLiteral("kcminputrc_mouse_cursorsize") });
152​ if (applyMouseStatus == 10) {
153​ qputenv("XCURSOR_THEME", "breeze_cursors");
154​ } else if (!kcminputrc_mouse_cursortheme.isEmpty()) {
155​ qputenv("XCURSOR_THEME", kcminputrc_mouse_cursortheme.toUtf8());
156​ }
157​ if (!kcminputrc_mouse_cursorsize.isEmpty()) {
158​ qputenv("XCURSOR_SIZE", kcminputrc_mouse_cursorsize.toUtf8());
159​ }
160​}
161​
162​// Source scripts found in <config locations>/plasma-workspace/env/*.sh
163​// (where <config locations> correspond to the system and user's configuration
164​// directory.
165​//
166​// This is where you can define environment variables that will be available to
167​// all KDE programs, so this is where you can run agents using e.g. eval `ssh-agent`
168​// or eval `gpg-agent --daemon`.
169​// Note: if you do that, you should also put "ssh-agent -k" as a shutdown script
170​//
171​// (see end of this file).
172​// For anything else (that doesn't set env vars, or that needs a window manager),
173​// better use the Autostart folder.
174​
175​void runEnvironmentScripts()
176​{
177​ QStringList scripts;
178​ const auto locations = QStandardPaths::locateAll(QStandardPaths::GenericConfigLocation, QStringLiteral("plasma-workspace/env"), QStandardPaths::LocateDirectory);
179​ for (const QString & location : locations) {
180​ QDir dir(location);
181​ const auto dirScripts = dir.entryInfoList({QStringLiteral("*.sh")});
182​ for (const auto script : dirScripts) {
183​ scripts << script.absoluteFilePath();
184​ }
185​ }
186​ sourceFiles(scripts);
187​
188​ // Make sure that the KDE prefix is first in XDG_DATA_DIRS and that it's set at all.
189​ // The spec allows XDG_DATA_DIRS to be not set, but X session startup scripts tend
190​ // to set it to a list of paths *not* including the KDE prefix if it's not /usr or
191​ // /usr/local.
192​ if (!qEnvironmentVariableIsSet("XDG_DATA_DIRS")) {
193​ qputenv("XDG_DATA_DIRS", KDE_INSTALL_FULL_DATAROOTDIR ":/usr/share:/usr/local/share");
194​ }
195​}
196​
197​
198​// Mark that full KDE session is running (e.g. Konqueror preloading works only
199​// with full KDE running). The KDE_FULL_SESSION property can be detected by
200​// any X client connected to the same X session, even if not launched
201​// directly from the KDE session but e.g. using "ssh -X", kdesu. $KDE_FULL_SESSION
202​// however guarantees that the application is launched in the same environment
203​// like the KDE session and that e.g. KDE utilities/libraries are available.
204​// KDE_FULL_SESSION property is also only available since KDE 3.5.5.
205​// The matching tests are:
206​// For $KDE_FULL_SESSION:
207​// if test -n "$KDE_FULL_SESSION"; then ... whatever
208​// For KDE_FULL_SESSION property (on X11):
209​// xprop -root | grep "^KDE_FULL_SESSION" >/dev/null 2>/dev/null
210​// if test $? -eq 0; then ... whatever
211​//
212​// Additionally there is $KDE_SESSION_UID with the uid
213​// of the user running the KDE session. It should be rarely needed (e.g.
214​// after sudo to prevent desktop-wide functionality in the new user's kded).
215​//
216​// Since KDE4 there is also KDE_SESSION_VERSION, containing the major version number.
217​//
218​
219​void setupPlasmaEnvironment()
220​{
221​ //Manually disable auto scaling because we are scaling above
222​ //otherwise apps that manually opt in for high DPI get auto scaled by the developer AND manually scaled by us
223​ qputenv("QT_AUTO_SCREEN_SCALE_FACTOR", "0");
224​
225​ qputenv("KDE_FULL_SESSION", "true");
226​ qputenv("KDE_SESSION_VERSION", "5");
227​ qputenv("KDE_SESSION_UID", QByteArray::number(getuid()));
228​ qputenv("XDG_CURRENT_DESKTOP", "KDE");
229​}
230​
231​void setupX11()
232​{
233​// Set a left cursor instead of the standard X11 "X" cursor, since I've heard
234​// from some users that they're confused and don't know what to do. This is
235​// especially necessary on slow machines, where starting KDE takes one or two
236​// minutes until anything appears on the screen.
237​//
238​// If the user has overwritten fonts, the cursor font may be different now
239​// so don't move this up.
240​
241​ runSync(QStringLiteral("xsetroot"), {QStringLiteral("-cursor_name"), QStringLiteral("left_ptr")});
broulikUnsubmitted
Not Done

Would it make a difference using libxcb for this instead of spawning an external process synchronously here?

broulik: Would it make a difference using libxcb for this instead of spawning an external process…
apolAuthorUnsubmitted
Not Done

I wonder so as well. Possibly. It would also make the process link against libxcb.
Something to try I'd say.

Maybe once it's in.

apol: I wonder so as well. Possibly. It would also make the process link against libxcb. Something to…
242​ runSync(QStringLiteral("xprop"), {QStringLiteral("-root"), QStringLiteral("-f"), QStringLiteral("KDE_FULL_SESSION"), QStringLiteral("8t"), QStringLiteral("-set"), QStringLiteral("KDE_FULL_SESSION"), QStringLiteral("true")});
243​ runSync(QStringLiteral("xprop"), {QStringLiteral("-root"), QStringLiteral("-f"), QStringLiteral("KDE_SESSION_VERSION"), QStringLiteral("32c"), QStringLiteral("-set"), QStringLiteral("KDE_SESSION_VERSION"), QStringLiteral("5")});
244​}
245​
246​void cleanupX11()
247​{
248​ runSync(QStringLiteral("xprop"), { QStringLiteral("-root"), QStringLiteral("-remove"), QStringLiteral("KDE_FULL_SESSION") });
249​ runSync(QStringLiteral("xprop"), { QStringLiteral("-root"), QStringLiteral("-remove"), QStringLiteral("KDE_SESSION_VERSION") });
250​}
251​
252​// TODO: Check if Necessary
253​void cleanupPlasmaEnvironment()
254​{
255​ qunsetenv("KDE_FULL_SESSION");
256​ qunsetenv("KDE_SESSION_VERSION");
257​ qunsetenv("KDE_SESSION_UID");
258​}
259​
davidedmundsonUnsubmitted
Done

braces

davidedmundson: braces
260​// kwin_wayland can possibly also start dbus-activated services which need env variables.
261​// In that case, the update in startplasma might be too late.
262​bool syncDBusEnvironment()
263​{
264​ int exitCode;
265​ // At this point all environment variables are set, let's send it to the DBus session server to update the activation environment
266​ if (!QStandardPaths::findExecutable(QStringLiteral("dbus-update-activation-environment")).isEmpty()) {
267​ exitCode = runSync(QStringLiteral("dbus-update-activation-environment"), { QStringLiteral("--systemd"), QStringLiteral("--all") });
268​ } else {
269​ exitCode = runSync(QStringLiteral(CMAKE_INSTALL_FULL_LIBEXECDIR "/ksyncdbusenv"), {});
270​ }
271​ return exitCode == 0;
272​}
273​
274​void setupFontDpi()
275​{
276​ KConfig cfg(QStringLiteral("kcmfonts"));
277​ KConfigGroup fontsCfg(&cfg, "General");
278​
279​ if (!fontsCfg.readEntry("forceFontDPI", false)) {
280​ return;
281​ }
282​
283​ //TODO port to c++?
284​ const QByteArray input = "Xft.dpi: kcmfonts_general_forcefontdpi";
285​ QProcess p;
davidedmundsonUnsubmitted
Done

This is wrong.

forceFontDPI is a number
we need to read that from the config file and send that to xrdb.

you can verify it works with

xrdb -q | grep Xft

in your session afterwards

davidedmundson: This is wrong. forceFontDPI is a number we need to read that from the config file and send…
apolAuthorUnsubmitted
Not Done

Good catch.

apol: Good catch.
286​ p.start(QStringLiteral("xrdb"), { QStringLiteral("-quiet"), QStringLiteral("-merge"), QStringLiteral("-nocpp") });
287​ p.setProcessChannelMode(QProcess::ForwardedChannels);
288​ p.write(input);
289​ p.closeWriteChannel();
290​ p.waitForFinished(-1);
291​}
292​
293​static bool dl = false;
broulikUnsubmitted
Done

descriptive variable name, please.

broulik: descriptive variable name, please.
294​
295​QProcess* setupKSplash()
296​{
297​ const auto dlstr = qgetenv("DESKTOP_LOCKED");
298​ dl = dlstr == "true" || dlstr == "1";
299​ qunsetenv("DESKTOP_LOCKED"); // Don't want it in the environment
300​
301​ QProcess* p = nullptr;
302​ if (!dl) {
303​ const KConfig cfg(QStringLiteral("ksplashrc"));
304​ // the splashscreen and progress indicator
305​ KConfigGroup ksplashCfg = cfg.group("KSplash");
306​ if (ksplashCfg.readEntry("Engine", QStringLiteral("KSplashQML")) == QLatin1String("KSplashQML")) {
307​ p = new QProcess;
308​ p->start(QStringLiteral("ksplashqml"), { ksplashCfg.readEntry("Theme", QStringLiteral("Breeze")) });
broulikUnsubmitted
Not Done

KSplash internally forks and prints the PID on stdout which doesn't seem neccessary anymore with this new code. (Optimization for the future maybe)

broulik: KSplash internally forks and prints the PID on stdout which doesn't seem neccessary anymore…
309​ }
310​ }
311​ return p;
312​}
313​
314​
315​void setupGSLib()
316​// Get Ghostscript to look into user's KDE fonts dir for additional Fontmap
317​{
318​ const QByteArray usr_fdir = QFile::encodeName(QDir::home().absoluteFilePath(QStringLiteral(".fonts")));
319​ if (qEnvironmentVariableIsSet("GS_LIB")) {
320​ qputenv("GS_LIB", usr_fdir + ':' + qgetenv("GS_LIB"));
321​ } else {
322​ qputenv("GS_LIB", usr_fdir);
323​ }
324​}
325​
326​bool startKDEInit()
327​{
328​ // We set LD_BIND_NOW to increase the efficiency of kdeinit.
329​ // kdeinit unsets this variable before loading applications.
330​ const int exitCode = runSync(QStringLiteral(CMAKE_INSTALL_FULL_LIBEXECDIR_KF5 "/start_kdeinit_wrapper"), { QStringLiteral("--kded"), QStringLiteral("+kcminit_startup") }, { QStringLiteral("LD_BIND_NOW=true") });
331​ if (exitCode != 0) {
332​ messageBox(QStringLiteral("startkde: Could not start kdeinit5. Check your installation."));
333​ return false;
334​ }
335​
336​ OrgKdeKSplashInterface iface(QStringLiteral("org.kde.KSplash"), QStringLiteral("/KSplash"), QDBusConnection::sessionBus());
337​ iface.setStage(QStringLiteral("kinit"));
338​ return true;
339​}
340​
341​bool startKSMServer()
342​{
343​ // finally, give the session control to the session manager
344​ // see kdebase/ksmserver for the description of the rest of the startup sequence
345​ // if the KDEWM environment variable has been set, then it will be used as KDE's
346​ // window manager instead of kwin.
347​ // if KDEWM is not set, ksmserver will ensure kwin is started.
348​ // kwrapper5 is used to reduce startup time and memory usage
349​ // kwrapper5 does not return useful error codes such as the exit code of ksmserver.
350​ // We only check for 255 which means that the ksmserver process could not be
351​ // started, any problems thereafter, e.g. ksmserver failing to initialize,
352​ // will remain undetected.
353​ // If the session should be locked from the start (locked autologin),
354​ // lock now and do the rest of the KDE startup underneath the locker.
355​
356​
357​ QStringList ksmserverOptions = { QStringLiteral(CMAKE_INSTALL_FULL_BINDIR "/ksmserver") };
358​ if (dl) {
359​ ksmserverOptions << QStringLiteral("--lockscreen");
360​ }
361​ const auto exitCode = runSync(QStringLiteral("kwrapper5"), ksmserverOptions);
362​
363​ if (exitCode == 255) {
364​ // Startup error
365​ messageBox(QStringLiteral("startkde: Could not start ksmserver. Check your installation.\n"));
366​ return false;
367​ }
368​ return true;
369​}
370​
371​void waitForKonqi()
372​{
373​ const KConfig cfg(QStringLiteral("startkderc"));
374​ const KConfigGroup grp = cfg.group("WaitForDrKonqi");
375​ bool wait_drkonqi = grp.readEntry("Enabled", true);
376​ if (wait_drkonqi) {
377​ // wait for remaining drkonqi instances with timeout (in seconds)
378​ const int wait_drkonqi_timeout = grp.readEntry("Timeout", 900) * 1000;
379​ QElapsedTimer wait_drkonqi_counter;
380​ wait_drkonqi_counter.start();
381​ QStringList services = allServices(QLatin1String("org.kde.drkonqi-"));
382​ while (!services.isEmpty()) {
383​ sleep(5);
384​ services = allServices(QLatin1String("org.kde.drkonqi-"));
385​ if (wait_drkonqi_counter.elapsed() >= wait_drkonqi_timeout) {
386​ // ask remaining drkonqis to die in a graceful way
387​ for (const auto &service: services) {
388​ QDBusInterface iface(service, QStringLiteral("/MainApplication"));
389​ iface.call(QStringLiteral("quit"));
390​ }
391​ break;
392​ }
393​ }
394​ }
395​}