2020-08-02 22:22:19 +00:00
|
|
|
/*
|
|
|
|
KWin - the KDE window manager
|
|
|
|
This file is part of the KDE project.
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2020-08-02 22:22:19 +00:00
|
|
|
SPDX-FileCopyrightText: 1999, 2000 Matthias Ettrich <ettrich@kde.org>
|
|
|
|
SPDX-FileCopyrightText: 2003 Lubos Lunak <l.lunak@kde.org>
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2020-08-02 22:22:19 +00:00
|
|
|
SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
*/
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2022-12-16 20:08:44 +00:00
|
|
|
#pragma once
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2024-02-14 10:57:50 +00:00
|
|
|
#include "config-kwin.h"
|
|
|
|
|
2023-11-17 08:59:08 +00:00
|
|
|
#include "effect/globals.h"
|
2014-08-12 07:08:48 +00:00
|
|
|
|
2016-01-29 08:48:02 +00:00
|
|
|
#include <KSharedConfig>
|
2022-07-20 09:52:22 +00:00
|
|
|
#include <memory>
|
2013-07-26 05:52:56 +00:00
|
|
|
// Qt
|
|
|
|
#include <QAbstractNativeEventFilter>
|
2022-03-23 10:13:38 +00:00
|
|
|
#include <QApplication>
|
2015-07-07 15:35:57 +00:00
|
|
|
#include <QProcessEnvironment>
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2023-12-15 16:58:46 +00:00
|
|
|
#if KWIN_BUILD_X11
|
2023-05-12 14:23:14 +00:00
|
|
|
#include <xcb/xcb.h>
|
2023-12-15 16:58:46 +00:00
|
|
|
#endif
|
2023-05-12 14:23:14 +00:00
|
|
|
|
2016-04-06 15:30:00 +00:00
|
|
|
class KPluginMetaData;
|
2014-08-12 07:08:48 +00:00
|
|
|
class QCommandLineParser;
|
|
|
|
|
2007-04-29 17:35:43 +00:00
|
|
|
namespace KWin
|
|
|
|
{
|
|
|
|
|
2022-11-05 10:43:41 +00:00
|
|
|
class OutputBackend;
|
2022-07-23 13:22:54 +00:00
|
|
|
class Session;
|
2021-01-31 12:12:02 +00:00
|
|
|
class X11EventFilter;
|
2022-07-20 09:52:22 +00:00
|
|
|
class PluginManager;
|
2022-07-20 10:14:27 +00:00
|
|
|
class InputMethod;
|
2022-07-20 10:27:28 +00:00
|
|
|
class ColorManager;
|
2022-07-31 12:40:08 +00:00
|
|
|
class ScreenLockerWatcher;
|
2022-08-03 09:27:35 +00:00
|
|
|
class TabletModeManager;
|
2022-08-03 10:31:27 +00:00
|
|
|
class XwaylandInterface;
|
2023-07-23 20:55:27 +00:00
|
|
|
class Cursor;
|
2022-11-05 10:14:59 +00:00
|
|
|
class Edge;
|
|
|
|
class ScreenEdges;
|
|
|
|
class Outline;
|
|
|
|
class OutlineVisual;
|
|
|
|
class Compositor;
|
2022-12-18 21:56:41 +00:00
|
|
|
class WorkspaceScene;
|
2022-11-05 10:14:59 +00:00
|
|
|
class Window;
|
2016-04-06 15:30:00 +00:00
|
|
|
|
2013-07-26 05:52:56 +00:00
|
|
|
class XcbEventFilter : public QAbstractNativeEventFilter
|
|
|
|
{
|
|
|
|
public:
|
2022-03-08 06:26:17 +00:00
|
|
|
bool nativeEventFilter(const QByteArray &eventType, void *message, qintptr *result) override;
|
2013-07-26 05:52:56 +00:00
|
|
|
};
|
|
|
|
|
2021-01-31 12:12:02 +00:00
|
|
|
class X11EventFilterContainer : public QObject
|
|
|
|
{
|
|
|
|
Q_OBJECT
|
|
|
|
|
|
|
|
public:
|
|
|
|
explicit X11EventFilterContainer(X11EventFilter *filter);
|
|
|
|
|
|
|
|
X11EventFilter *filter() const;
|
|
|
|
|
|
|
|
private:
|
|
|
|
X11EventFilter *m_filter;
|
|
|
|
};
|
|
|
|
|
2022-03-23 10:13:38 +00:00
|
|
|
class KWIN_EXPORT Application : public QApplication
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2007-04-29 17:35:43 +00:00
|
|
|
Q_OBJECT
|
2023-12-15 16:58:46 +00:00
|
|
|
#if KWIN_BUILD_X11
|
2015-02-19 08:59:21 +00:00
|
|
|
Q_PROPERTY(quint32 x11Time READ x11Time WRITE setX11Time)
|
2015-02-18 07:31:53 +00:00
|
|
|
Q_PROPERTY(quint32 x11RootWindow READ x11RootWindow CONSTANT)
|
2015-02-18 10:19:04 +00:00
|
|
|
Q_PROPERTY(void *x11Connection READ x11Connection NOTIFY x11ConnectionChanged)
|
2023-12-15 16:58:46 +00:00
|
|
|
#endif
|
2016-11-16 15:53:17 +00:00
|
|
|
Q_PROPERTY(KSharedConfigPtr config READ config WRITE setConfig)
|
2017-01-27 16:15:32 +00:00
|
|
|
Q_PROPERTY(KSharedConfigPtr kxkbConfig READ kxkbConfig WRITE setKxkbConfig)
|
2011-01-30 14:34:42 +00:00
|
|
|
public:
|
2013-06-25 06:52:08 +00:00
|
|
|
/**
|
2019-02-02 18:17:44 +00:00
|
|
|
* @brief This enum provides the various operation modes of KWin depending on the available
|
|
|
|
* Windowing Systems at startup. For example whether KWin only talks to X11 or also to a Wayland
|
|
|
|
* Compositor.
|
|
|
|
*
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2013-06-25 06:52:08 +00:00
|
|
|
enum OperationMode {
|
|
|
|
/**
|
2019-02-02 18:17:44 +00:00
|
|
|
* @brief KWin uses only X11 for managing windows and compositing
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2013-06-25 06:52:08 +00:00
|
|
|
OperationModeX11,
|
|
|
|
/**
|
2017-09-30 13:09:06 +00:00
|
|
|
* @brief KWin uses only Wayland
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2017-09-30 13:09:06 +00:00
|
|
|
OperationModeWaylandOnly,
|
2015-01-09 15:00:16 +00:00
|
|
|
/**
|
|
|
|
* @brief KWin uses Wayland and controls a nested Xwayland server.
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2015-01-09 15:00:16 +00:00
|
|
|
OperationModeXwayland
|
2013-06-25 06:52:08 +00:00
|
|
|
};
|
2022-02-02 03:35:13 +00:00
|
|
|
Q_ENUM(OperationMode)
|
Run clang-tidy with modernize-use-override check
Summary:
Currently code base of kwin can be viewed as two pieces. One is very
ancient, and the other one is more modern, which uses new C++ features.
The main problem with the ancient code is that it was written before
C++11 era. So, no override or final keywords, lambdas, etc.
Quite recently, KDE compiler settings were changed to show a warning if
a virtual method has missing override keyword. As you might have already
guessed, this fired back at us because of that ancient code. We had
about 500 new compiler warnings.
A "solution" was proposed to that problem - disable -Wno-suggest-override
and the other similar warning for clang. It's hard to call a solution
because those warnings are disabled not only for the old code, but also
for new. This is not what we want!
The main argument for not actually fixing the problem was that git
history will be screwed as well because of human factor. While good git
history is a very important thing, we should not go crazy about it and
block every change that somehow alters git history. git blame allows to
specify starting revision for a reason.
The other argument (human factor) can be easily solved by using tools
such as clang-tidy. clang-tidy is a clang-based linter for C++. It can
be used for various things, e.g. fixing coding style(e.g. add missing
braces to if statements, readability-braces-around-statements check),
or in our case add missing override keywords.
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, apol, romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D22371
2019-07-22 16:52:26 +00:00
|
|
|
~Application() override;
|
2011-01-30 14:34:42 +00:00
|
|
|
|
2013-08-28 12:10:51 +00:00
|
|
|
void setConfigLock(bool lock);
|
|
|
|
|
2022-03-23 10:13:38 +00:00
|
|
|
KSharedConfigPtr config() const
|
|
|
|
{
|
2016-01-29 08:48:02 +00:00
|
|
|
return m_config;
|
|
|
|
}
|
2022-03-23 10:13:38 +00:00
|
|
|
void setConfig(KSharedConfigPtr config)
|
|
|
|
{
|
2019-10-29 22:04:15 +00:00
|
|
|
m_config = std::move(config);
|
2016-01-29 08:48:02 +00:00
|
|
|
}
|
|
|
|
|
2022-03-23 10:13:38 +00:00
|
|
|
KSharedConfigPtr kxkbConfig() const
|
|
|
|
{
|
2017-01-27 16:15:32 +00:00
|
|
|
return m_kxkbConfig;
|
|
|
|
}
|
2022-03-23 10:13:38 +00:00
|
|
|
void setKxkbConfig(KSharedConfigPtr config)
|
|
|
|
{
|
2019-10-29 22:04:15 +00:00
|
|
|
m_kxkbConfig = std::move(config);
|
2017-01-27 16:15:32 +00:00
|
|
|
}
|
|
|
|
|
2023-06-21 09:03:49 +00:00
|
|
|
KSharedConfigPtr inputConfig() const
|
|
|
|
{
|
|
|
|
return m_inputConfig;
|
|
|
|
}
|
|
|
|
void setInputConfig(KSharedConfigPtr config)
|
|
|
|
{
|
|
|
|
m_inputConfig = std::move(config);
|
|
|
|
}
|
|
|
|
|
2013-08-28 12:10:51 +00:00
|
|
|
void start();
|
2013-06-25 06:52:08 +00:00
|
|
|
/**
|
2019-02-02 18:17:44 +00:00
|
|
|
* @brief The operation mode used by KWin.
|
|
|
|
*
|
|
|
|
* @return OperationMode
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2013-06-25 06:52:08 +00:00
|
|
|
OperationMode operationMode() const;
|
|
|
|
void setOperationMode(OperationMode mode);
|
2013-06-25 07:53:45 +00:00
|
|
|
bool shouldUseWaylandForCompositing() const;
|
2013-08-28 12:10:51 +00:00
|
|
|
|
2014-08-12 07:08:48 +00:00
|
|
|
void setupCommandLine(QCommandLineParser *parser);
|
|
|
|
void processCommandLine(QCommandLineParser *parser);
|
|
|
|
|
2023-12-15 16:58:46 +00:00
|
|
|
#if KWIN_BUILD_X11
|
2021-01-31 12:12:02 +00:00
|
|
|
void registerEventFilter(X11EventFilter *filter);
|
|
|
|
void unregisterEventFilter(X11EventFilter *filter);
|
|
|
|
bool dispatchEvent(xcb_generic_event_t *event);
|
|
|
|
|
2022-03-23 10:13:38 +00:00
|
|
|
xcb_timestamp_t x11Time() const
|
|
|
|
{
|
2015-02-19 08:59:21 +00:00
|
|
|
return m_x11Time;
|
|
|
|
}
|
2017-05-03 19:17:25 +00:00
|
|
|
enum class TimestampUpdate {
|
|
|
|
OnlyIfLarger,
|
|
|
|
Always
|
|
|
|
};
|
2022-03-23 10:13:38 +00:00
|
|
|
void setX11Time(xcb_timestamp_t timestamp, TimestampUpdate force = TimestampUpdate::OnlyIfLarger)
|
|
|
|
{
|
2017-05-06 17:52:41 +00:00
|
|
|
if ((timestamp > m_x11Time || force == TimestampUpdate::Always) && timestamp != 0) {
|
2015-02-19 08:59:21 +00:00
|
|
|
m_x11Time = timestamp;
|
|
|
|
}
|
|
|
|
}
|
2022-10-08 10:41:53 +00:00
|
|
|
/**
|
|
|
|
* Queries the current X11 time stamp of the X server.
|
|
|
|
*/
|
|
|
|
void updateXTime();
|
2015-02-19 08:59:21 +00:00
|
|
|
void updateX11Time(xcb_generic_event_t *event);
|
2023-12-15 16:58:46 +00:00
|
|
|
#endif
|
2015-02-19 08:59:21 +00:00
|
|
|
|
2013-08-28 12:10:51 +00:00
|
|
|
static void setCrashCount(int count);
|
|
|
|
static bool wasCrash();
|
2020-09-23 18:39:59 +00:00
|
|
|
void resetCrashesCount();
|
2013-08-28 12:10:51 +00:00
|
|
|
|
2014-08-12 07:08:48 +00:00
|
|
|
/**
|
|
|
|
* Creates the KAboutData object for the KWin instance and registers it as
|
|
|
|
* KAboutData::setApplicationData.
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2014-08-12 07:08:48 +00:00
|
|
|
static void createAboutData();
|
|
|
|
|
2023-12-15 16:58:46 +00:00
|
|
|
#if KWIN_BUILD_X11
|
2015-02-18 07:31:53 +00:00
|
|
|
/**
|
|
|
|
* @returns the X11 root window.
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2022-03-23 10:13:38 +00:00
|
|
|
xcb_window_t x11RootWindow() const
|
|
|
|
{
|
2015-02-18 07:31:53 +00:00
|
|
|
return m_rootWindow;
|
|
|
|
}
|
|
|
|
|
2023-09-19 08:51:42 +00:00
|
|
|
/**
|
|
|
|
* @returns the X11 composite overlay window handle.
|
|
|
|
*/
|
|
|
|
xcb_window_t x11CompositeWindow() const
|
|
|
|
{
|
|
|
|
return m_compositeWindow;
|
|
|
|
}
|
|
|
|
|
2015-02-18 10:19:04 +00:00
|
|
|
/**
|
|
|
|
* @returns the X11 xcb connection
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2022-03-23 10:13:38 +00:00
|
|
|
xcb_connection_t *x11Connection() const
|
|
|
|
{
|
2015-02-18 10:19:04 +00:00
|
|
|
return m_connection;
|
|
|
|
}
|
2022-07-15 07:15:54 +00:00
|
|
|
/**
|
|
|
|
* Inheriting classes should use this method to set the X11 root window
|
|
|
|
* before accessing any X11 specific code pathes.
|
|
|
|
*/
|
|
|
|
void setX11RootWindow(xcb_window_t root)
|
|
|
|
{
|
|
|
|
m_rootWindow = root;
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
* Inheriting classes should use this method to set the xcb connection
|
|
|
|
* before accessing any X11 specific code pathes.
|
|
|
|
*/
|
|
|
|
void setX11Connection(xcb_connection_t *c)
|
|
|
|
{
|
|
|
|
m_connection = c;
|
|
|
|
}
|
2023-09-19 08:51:42 +00:00
|
|
|
void setX11CompositeWindow(xcb_window_t window)
|
|
|
|
{
|
|
|
|
m_compositeWindow = window;
|
|
|
|
}
|
2023-12-15 16:58:46 +00:00
|
|
|
#endif
|
2022-07-15 07:15:54 +00:00
|
|
|
|
2022-02-02 03:35:13 +00:00
|
|
|
qreal xwaylandScale() const
|
|
|
|
{
|
|
|
|
return m_xwaylandScale;
|
|
|
|
}
|
|
|
|
|
|
|
|
void setXwaylandScale(qreal scale);
|
|
|
|
|
2022-02-28 18:58:35 +00:00
|
|
|
#if KWIN_BUILD_ACTIVITIES
|
2022-03-23 10:13:38 +00:00
|
|
|
bool usesKActivities() const
|
|
|
|
{
|
2015-11-24 08:01:46 +00:00
|
|
|
return m_useKActivities;
|
|
|
|
}
|
2022-03-23 10:13:38 +00:00
|
|
|
void setUseKActivities(bool use)
|
|
|
|
{
|
2015-11-24 08:01:46 +00:00
|
|
|
m_useKActivities = use;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2022-07-15 07:15:54 +00:00
|
|
|
QProcessEnvironment processStartupEnvironment() const;
|
|
|
|
void setProcessStartupEnvironment(const QProcessEnvironment &environment);
|
2015-07-07 15:35:57 +00:00
|
|
|
|
2022-11-05 10:43:41 +00:00
|
|
|
OutputBackend *outputBackend() const
|
2022-03-23 10:13:38 +00:00
|
|
|
{
|
2022-11-05 10:43:41 +00:00
|
|
|
return m_outputBackend.get();
|
2016-04-06 15:30:00 +00:00
|
|
|
}
|
2022-11-05 10:43:41 +00:00
|
|
|
void setOutputBackend(std::unique_ptr<OutputBackend> &&backend);
|
2016-04-06 15:30:00 +00:00
|
|
|
|
2022-07-23 13:22:54 +00:00
|
|
|
Session *session() const
|
|
|
|
{
|
|
|
|
return m_session.get();
|
|
|
|
}
|
|
|
|
void setSession(std::unique_ptr<Session> &&session);
|
2022-09-08 22:18:12 +00:00
|
|
|
void setFollowLocale1(bool follow)
|
|
|
|
{
|
|
|
|
m_followLocale1 = follow;
|
|
|
|
}
|
|
|
|
bool followLocale1() const
|
|
|
|
{
|
|
|
|
return m_followLocale1;
|
|
|
|
}
|
2022-07-23 13:22:54 +00:00
|
|
|
|
2022-03-23 10:13:38 +00:00
|
|
|
bool isTerminating() const
|
|
|
|
{
|
2019-01-06 16:05:10 +00:00
|
|
|
return m_terminating;
|
|
|
|
}
|
|
|
|
|
2022-07-15 07:15:54 +00:00
|
|
|
void installNativeX11EventFilter();
|
|
|
|
void removeNativeX11EventFilter();
|
|
|
|
|
|
|
|
void createAtoms();
|
|
|
|
void destroyAtoms();
|
|
|
|
|
2022-11-05 10:14:59 +00:00
|
|
|
virtual std::unique_ptr<Edge> createScreenEdge(ScreenEdges *parent);
|
2023-07-23 20:55:27 +00:00
|
|
|
virtual std::unique_ptr<Cursor> createPlatformCursor();
|
2022-11-05 10:14:59 +00:00
|
|
|
virtual std::unique_ptr<OutlineVisual> createOutline(Outline *outline);
|
2022-12-18 21:56:41 +00:00
|
|
|
virtual void createEffectsHandler(Compositor *compositor, WorkspaceScene *scene);
|
2022-11-05 10:14:59 +00:00
|
|
|
|
2014-08-12 07:08:48 +00:00
|
|
|
static void setupMalloc();
|
|
|
|
static void setupLocalizedString();
|
|
|
|
|
2022-07-20 09:52:22 +00:00
|
|
|
PluginManager *pluginManager() const;
|
2022-07-20 10:14:27 +00:00
|
|
|
InputMethod *inputMethod() const;
|
2022-07-20 10:27:28 +00:00
|
|
|
ColorManager *colorManager() const;
|
2022-08-03 10:31:27 +00:00
|
|
|
virtual XwaylandInterface *xwayland() const;
|
2022-07-31 12:40:08 +00:00
|
|
|
#if KWIN_BUILD_SCREENLOCKER
|
|
|
|
ScreenLockerWatcher *screenLockerWatcher() const;
|
|
|
|
#endif
|
2023-09-13 15:15:04 +00:00
|
|
|
TabletModeManager *tabletModeManager() const;
|
2022-07-20 09:52:22 +00:00
|
|
|
|
2022-11-05 10:14:59 +00:00
|
|
|
/**
|
|
|
|
* Starts an interactive window selection process.
|
|
|
|
*
|
|
|
|
* Once the user selected a window the @p callback is invoked with the selected Window as
|
|
|
|
* argument. In case the user cancels the interactive window selection or selecting a window is currently
|
|
|
|
* not possible (e.g. screen locked) the @p callback is invoked with a @c nullptr argument.
|
|
|
|
*
|
|
|
|
* During the interactive window selection the cursor is turned into a crosshair cursor unless
|
|
|
|
* @p cursorName is provided. The argument @p cursorName is a QByteArray instead of Qt::CursorShape
|
|
|
|
* to support the "pirate" cursor for kill window which is not wrapped by Qt::CursorShape.
|
|
|
|
*
|
|
|
|
* The default implementation forwards to InputRedirection.
|
|
|
|
*
|
|
|
|
* @param callback The function to invoke once the interactive window selection ends
|
|
|
|
* @param cursorName The optional name of the cursor shape to use, default is crosshair
|
|
|
|
*/
|
|
|
|
virtual void startInteractiveWindowSelection(std::function<void(KWin::Window *)> callback, const QByteArray &cursorName = QByteArray());
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Starts an interactive position selection process.
|
|
|
|
*
|
|
|
|
* Once the user selected a position on the screen the @p callback is invoked with
|
|
|
|
* the selected point as argument. In case the user cancels the interactive position selection
|
|
|
|
* or selecting a position is currently not possible (e.g. screen locked) the @p callback
|
|
|
|
* is invoked with a point at @c -1 as x and y argument.
|
|
|
|
*
|
|
|
|
* During the interactive window selection the cursor is turned into a crosshair cursor.
|
|
|
|
*
|
|
|
|
* The default implementation forwards to InputRedirection.
|
|
|
|
*
|
|
|
|
* @param callback The function to invoke once the interactive position selection ends
|
|
|
|
*/
|
2023-02-19 23:35:44 +00:00
|
|
|
virtual void startInteractivePositionSelection(std::function<void(const QPointF &)> callback);
|
2022-11-05 10:14:59 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns a PlatformCursorImage. By default this is created by softwareCursor and
|
|
|
|
* softwareCursorHotspot. An implementing subclass can use this to provide a better
|
|
|
|
* suited PlatformCursorImage.
|
|
|
|
*
|
|
|
|
* @see softwareCursor
|
|
|
|
* @see softwareCursorHotspot
|
|
|
|
* @since 5.9
|
|
|
|
*/
|
|
|
|
virtual PlatformCursorImage cursorImage() const;
|
|
|
|
|
2015-02-18 10:19:04 +00:00
|
|
|
Q_SIGNALS:
|
|
|
|
void x11ConnectionChanged();
|
2015-11-12 14:13:42 +00:00
|
|
|
void x11ConnectionAboutToBeDestroyed();
|
2022-02-02 03:35:13 +00:00
|
|
|
void xwaylandScaleChanged();
|
2015-02-23 14:53:24 +00:00
|
|
|
void workspaceCreated();
|
2015-04-15 15:47:56 +00:00
|
|
|
void virtualTerminalCreated();
|
2020-07-07 09:32:29 +00:00
|
|
|
void started();
|
2015-02-18 10:19:04 +00:00
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
protected:
|
2014-08-12 07:08:48 +00:00
|
|
|
Application(OperationMode mode, int &argc, char **argv);
|
|
|
|
virtual void performStartup() = 0;
|
|
|
|
|
|
|
|
void notifyKSplash();
|
2020-07-07 09:32:29 +00:00
|
|
|
void notifyStarted();
|
2015-02-20 13:53:03 +00:00
|
|
|
void createInput();
|
2014-08-12 07:08:48 +00:00
|
|
|
void createWorkspace();
|
|
|
|
void createOptions();
|
2020-11-26 18:41:20 +00:00
|
|
|
void createPlugins();
|
2020-11-27 19:37:40 +00:00
|
|
|
void createColorManager();
|
2021-10-14 07:40:08 +00:00
|
|
|
void createInputMethod();
|
2022-08-03 09:27:35 +00:00
|
|
|
void createTabletModeManager();
|
2021-09-27 10:02:24 +00:00
|
|
|
void destroyInput();
|
2014-08-12 07:08:48 +00:00
|
|
|
void destroyWorkspace();
|
2015-05-27 07:09:05 +00:00
|
|
|
void destroyCompositor();
|
2020-11-26 18:41:20 +00:00
|
|
|
void destroyPlugins();
|
2020-11-27 19:37:40 +00:00
|
|
|
void destroyColorManager();
|
2021-10-14 07:40:08 +00:00
|
|
|
void destroyInputMethod();
|
Fix crash in XRenderPictureData::~XRenderPictureData
Summary:
If the XRender scene has cross-faded a window, then, eventually, KWin/X11 will
crash in the destructor of the XRenderPictureData class during tear down with
the following message in the terminal
```
ASSERT: "qApp" in file /home/vlad/Workspace/KDE/src/kde/workspace/kwin/libkwineffects/kwinxrenderutils.cpp, line 163
```
The crash happens because X11StandalonePlatform attempts to clean up XRender
resources, including XRenderUtils::s_blendPicture, after the application object
has been destroyed.
In order to fix the crash, we have to destroy the platform object before the
destructor of QCoreApplication is executed.
Test Plan:
- Enable maximize effect
- Maximize a window
- Replace the current instance of KWin/X11 with another one
Without this patch, KWin/X11 crashes after the third step.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D25768
2019-12-12 12:06:20 +00:00
|
|
|
void destroyPlatform();
|
2023-10-06 10:44:27 +00:00
|
|
|
void applyXwaylandScale();
|
2014-08-12 07:08:48 +00:00
|
|
|
|
2022-03-23 10:13:38 +00:00
|
|
|
void setTerminating()
|
|
|
|
{
|
2019-01-06 16:05:10 +00:00
|
|
|
m_terminating = true;
|
|
|
|
}
|
|
|
|
|
2015-05-01 14:55:15 +00:00
|
|
|
protected:
|
2016-05-06 14:28:29 +00:00
|
|
|
static int crashes;
|
2015-05-01 14:55:15 +00:00
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
private:
|
2023-12-15 16:58:46 +00:00
|
|
|
#if KWIN_BUILD_X11
|
2021-01-31 12:12:02 +00:00
|
|
|
QList<QPointer<X11EventFilterContainer>> m_eventFilters;
|
|
|
|
QList<QPointer<X11EventFilterContainer>> m_genericEventFilters;
|
2022-08-01 21:29:02 +00:00
|
|
|
std::unique_ptr<XcbEventFilter> m_eventFilter;
|
2023-12-15 16:58:46 +00:00
|
|
|
#endif
|
2022-09-08 22:18:12 +00:00
|
|
|
bool m_followLocale1 = false;
|
2013-08-28 12:10:51 +00:00
|
|
|
bool m_configLock;
|
2016-01-29 08:48:02 +00:00
|
|
|
KSharedConfigPtr m_config;
|
2017-01-27 16:15:32 +00:00
|
|
|
KSharedConfigPtr m_kxkbConfig;
|
2023-06-21 09:03:49 +00:00
|
|
|
KSharedConfigPtr m_inputConfig;
|
2013-06-25 06:52:08 +00:00
|
|
|
OperationMode m_operationMode;
|
2023-12-15 16:58:46 +00:00
|
|
|
#if KWIN_BUILD_X11
|
2015-02-19 08:59:21 +00:00
|
|
|
xcb_timestamp_t m_x11Time = XCB_TIME_CURRENT_TIME;
|
2015-02-18 07:31:53 +00:00
|
|
|
xcb_window_t m_rootWindow = XCB_WINDOW_NONE;
|
2023-09-19 08:51:42 +00:00
|
|
|
xcb_window_t m_compositeWindow = XCB_WINDOW_NONE;
|
2015-02-18 10:19:04 +00:00
|
|
|
xcb_connection_t *m_connection = nullptr;
|
2023-12-15 16:58:46 +00:00
|
|
|
#endif
|
2022-02-28 18:58:35 +00:00
|
|
|
#if KWIN_BUILD_ACTIVITIES
|
2015-11-24 08:01:46 +00:00
|
|
|
bool m_useKActivities = true;
|
|
|
|
#endif
|
2022-07-23 13:22:54 +00:00
|
|
|
std::unique_ptr<Session> m_session;
|
2022-11-05 10:43:41 +00:00
|
|
|
std::unique_ptr<OutputBackend> m_outputBackend;
|
2019-01-06 16:05:10 +00:00
|
|
|
bool m_terminating = false;
|
2022-02-02 03:35:13 +00:00
|
|
|
qreal m_xwaylandScale = 1;
|
2022-07-15 07:15:54 +00:00
|
|
|
QProcessEnvironment m_processEnvironment;
|
2022-07-20 09:52:22 +00:00
|
|
|
std::unique_ptr<PluginManager> m_pluginManager;
|
2022-07-20 10:14:27 +00:00
|
|
|
std::unique_ptr<InputMethod> m_inputMethod;
|
2022-07-20 10:27:28 +00:00
|
|
|
std::unique_ptr<ColorManager> m_colorManager;
|
2022-08-03 09:27:35 +00:00
|
|
|
std::unique_ptr<TabletModeManager> m_tabletModeManager;
|
2022-07-31 12:40:08 +00:00
|
|
|
#if KWIN_BUILD_SCREENLOCKER
|
|
|
|
std::unique_ptr<ScreenLockerWatcher> m_screenLockerWatcher;
|
|
|
|
#endif
|
2023-07-23 20:55:27 +00:00
|
|
|
std::unique_ptr<Cursor> m_platformCursor;
|
2011-01-30 14:34:42 +00:00
|
|
|
};
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2014-01-09 13:47:57 +00:00
|
|
|
inline static Application *kwinApp()
|
|
|
|
{
|
2022-12-28 11:25:38 +00:00
|
|
|
Q_ASSERT(qobject_cast<Application *>(QCoreApplication::instance()));
|
|
|
|
|
2022-03-23 10:13:38 +00:00
|
|
|
return static_cast<Application *>(QCoreApplication::instance());
|
2014-01-09 13:47:57 +00:00
|
|
|
}
|
|
|
|
|
2007-04-29 17:35:43 +00:00
|
|
|
} // namespace
|