19ad172584
If the Xwayland process crashes, it will bring down the entire session together with itself. Obviously, we don't want that. At least, Wayland clients should survive the crash. This change refactors relevant X11 parts to handle Xwayland crashes in a less fatal way. In order to handle Xwayland crashes better, a pair of start() and stop() methods had been introduced in the Xwayland class to allow starting and stopping the Xwayland process at any moment. If we detect that the Xwayland process has crashed, we will immediately stop the Xwayland server, which in its turn will deactivate the socket notifier and destroy all connected X11 clients. Unfortunately, a couple of subtle changes in X11Client::releaseWindow() and Unmanaged::release() had to be made to ensure that we are left with a valid state after the Xwayland server has been stopped.
392 lines
12 KiB
C++
392 lines
12 KiB
C++
/********************************************************************
|
|
KWin - the KDE window manager
|
|
This file is part of the KDE project.
|
|
|
|
Copyright (C) 2004 Lubos Lunak <l.lunak@kde.org>
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*********************************************************************/
|
|
|
|
#ifndef KWIN_RULES_H
|
|
#define KWIN_RULES_H
|
|
|
|
|
|
#include <netwm_def.h>
|
|
#include <QRect>
|
|
#include <QVector>
|
|
|
|
#include "placement.h"
|
|
#include "options.h"
|
|
#include "utils.h"
|
|
|
|
class QDebug;
|
|
class KConfig;
|
|
class KXMessages;
|
|
|
|
namespace KWin
|
|
{
|
|
|
|
class AbstractClient;
|
|
class Rules;
|
|
class RuleSettings;
|
|
|
|
#ifndef KCMRULES // only for kwin core
|
|
|
|
class WindowRules
|
|
{
|
|
public:
|
|
explicit WindowRules(const QVector< Rules* >& rules);
|
|
WindowRules();
|
|
void update(AbstractClient*, int selection);
|
|
void discardTemporary();
|
|
bool contains(const Rules* rule) const;
|
|
void remove(Rules* rule);
|
|
Placement::Policy checkPlacement(Placement::Policy placement) const;
|
|
QRect checkGeometry(QRect rect, bool init = false) const;
|
|
// use 'invalidPoint' with checkPosition, unlike QSize() and QRect(), QPoint() is a valid point
|
|
QPoint checkPosition(QPoint pos, bool init = false) const;
|
|
QSize checkSize(QSize s, bool init = false) const;
|
|
QSize checkMinSize(QSize s) const;
|
|
QSize checkMaxSize(QSize s) const;
|
|
int checkOpacityActive(int s) const;
|
|
int checkOpacityInactive(int s) const;
|
|
bool checkIgnoreGeometry(bool ignore, bool init = false) const;
|
|
int checkDesktop(int desktop, bool init = false) const;
|
|
int checkScreen(int screen, bool init = false) const;
|
|
QString checkActivity(QString activity, bool init = false) const;
|
|
NET::WindowType checkType(NET::WindowType type) const;
|
|
MaximizeMode checkMaximize(MaximizeMode mode, bool init = false) const;
|
|
bool checkMinimize(bool minimized, bool init = false) const;
|
|
ShadeMode checkShade(ShadeMode shade, bool init = false) const;
|
|
bool checkSkipTaskbar(bool skip, bool init = false) const;
|
|
bool checkSkipPager(bool skip, bool init = false) const;
|
|
bool checkSkipSwitcher(bool skip, bool init = false) const;
|
|
bool checkKeepAbove(bool above, bool init = false) const;
|
|
bool checkKeepBelow(bool below, bool init = false) const;
|
|
bool checkFullScreen(bool fs, bool init = false) const;
|
|
bool checkNoBorder(bool noborder, bool init = false) const;
|
|
QString checkDecoColor(QString schemeFile) const;
|
|
bool checkBlockCompositing(bool block) const;
|
|
int checkFSP(int fsp) const;
|
|
int checkFPP(int fpp) const;
|
|
bool checkAcceptFocus(bool focus) const;
|
|
bool checkCloseable(bool closeable) const;
|
|
bool checkAutogrouping(bool autogroup) const;
|
|
bool checkAutogroupInForeground(bool fg) const;
|
|
QString checkAutogroupById(QString id) const;
|
|
bool checkStrictGeometry(bool strict) const;
|
|
QString checkShortcut(QString s, bool init = false) const;
|
|
bool checkDisableGlobalShortcuts(bool disable) const;
|
|
QString checkDesktopFile(QString desktopFile, bool init = false) const;
|
|
private:
|
|
MaximizeMode checkMaximizeVert(MaximizeMode mode, bool init) const;
|
|
MaximizeMode checkMaximizeHoriz(MaximizeMode mode, bool init) const;
|
|
QVector< Rules* > rules;
|
|
};
|
|
|
|
#endif
|
|
|
|
class Rules
|
|
{
|
|
public:
|
|
Rules();
|
|
explicit Rules(const RuleSettings*);
|
|
Rules(const QString&, bool temporary);
|
|
enum Type {
|
|
Position = 1<<0, Size = 1<<1, Desktop = 1<<2,
|
|
MaximizeVert = 1<<3, MaximizeHoriz = 1<<4, Minimize = 1<<5,
|
|
Shade = 1<<6, SkipTaskbar = 1<<7, SkipPager = 1<<8,
|
|
SkipSwitcher = 1<<9, Above = 1<<10, Below = 1<<11, Fullscreen = 1<<12,
|
|
NoBorder = 1<<13, OpacityActive = 1<<14, OpacityInactive = 1<<15,
|
|
Activity = 1<<16, Screen = 1<<17, DesktopFile = 1 << 18, All = 0xffffffff
|
|
};
|
|
Q_DECLARE_FLAGS(Types, Type)
|
|
// All these values are saved to the cfg file, and are also used in kstart!
|
|
enum {
|
|
Unused = 0,
|
|
DontAffect, // use the default value
|
|
Force, // force the given value
|
|
Apply, // apply only after initial mapping
|
|
Remember, // like apply, and remember the value when the window is withdrawn
|
|
ApplyNow, // apply immediatelly, then forget the setting
|
|
ForceTemporarily // apply and force until the window is withdrawn
|
|
};
|
|
enum StringMatch {
|
|
FirstStringMatch,
|
|
UnimportantMatch = FirstStringMatch,
|
|
ExactMatch,
|
|
SubstringMatch,
|
|
RegExpMatch,
|
|
LastStringMatch = RegExpMatch
|
|
};
|
|
enum SetRule {
|
|
UnusedSetRule = Unused,
|
|
SetRuleDummy = 256 // so that it's at least short int
|
|
};
|
|
enum ForceRule {
|
|
UnusedForceRule = Unused,
|
|
ForceRuleDummy = 256 // so that it's at least short int
|
|
};
|
|
void write(RuleSettings*) const;
|
|
bool isEmpty() const;
|
|
#ifndef KCMRULES
|
|
bool discardUsed(bool withdrawn);
|
|
bool match(const AbstractClient* c) const;
|
|
bool update(AbstractClient*, int selection);
|
|
bool isTemporary() const;
|
|
bool discardTemporary(bool force); // removes if temporary and forced or too old
|
|
bool applyPlacement(Placement::Policy& placement) const;
|
|
bool applyGeometry(QRect& rect, bool init) const;
|
|
// use 'invalidPoint' with applyPosition, unlike QSize() and QRect(), QPoint() is a valid point
|
|
bool applyPosition(QPoint& pos, bool init) const;
|
|
bool applySize(QSize& s, bool init) const;
|
|
bool applyMinSize(QSize& s) const;
|
|
bool applyMaxSize(QSize& s) const;
|
|
bool applyOpacityActive(int& s) const;
|
|
bool applyOpacityInactive(int& s) const;
|
|
bool applyIgnoreGeometry(bool& ignore, bool init) const;
|
|
bool applyDesktop(int& desktop, bool init) const;
|
|
bool applyScreen(int& desktop, bool init) const;
|
|
bool applyActivity(QString& activity, bool init) const;
|
|
bool applyType(NET::WindowType& type) const;
|
|
bool applyMaximizeVert(MaximizeMode& mode, bool init) const;
|
|
bool applyMaximizeHoriz(MaximizeMode& mode, bool init) const;
|
|
bool applyMinimize(bool& minimized, bool init) const;
|
|
bool applyShade(ShadeMode& shade, bool init) const;
|
|
bool applySkipTaskbar(bool& skip, bool init) const;
|
|
bool applySkipPager(bool& skip, bool init) const;
|
|
bool applySkipSwitcher(bool& skip, bool init) const;
|
|
bool applyKeepAbove(bool& above, bool init) const;
|
|
bool applyKeepBelow(bool& below, bool init) const;
|
|
bool applyFullScreen(bool& fs, bool init) const;
|
|
bool applyNoBorder(bool& noborder, bool init) const;
|
|
bool applyDecoColor(QString &schemeFile) const;
|
|
bool applyBlockCompositing(bool& block) const;
|
|
bool applyFSP(int& fsp) const;
|
|
bool applyFPP(int& fpp) const;
|
|
bool applyAcceptFocus(bool& focus) const;
|
|
bool applyCloseable(bool& closeable) const;
|
|
bool applyAutogrouping(bool& autogroup) const;
|
|
bool applyAutogroupInForeground(bool& fg) const;
|
|
bool applyAutogroupById(QString& id) const;
|
|
bool applyStrictGeometry(bool& strict) const;
|
|
bool applyShortcut(QString& shortcut, bool init) const;
|
|
bool applyDisableGlobalShortcuts(bool& disable) const;
|
|
bool applyDesktopFile(QString &desktopFile, bool init) const;
|
|
private:
|
|
#endif
|
|
bool matchType(NET::WindowType match_type) const;
|
|
bool matchWMClass(const QByteArray& match_class, const QByteArray& match_name) const;
|
|
bool matchRole(const QByteArray& match_role) const;
|
|
bool matchTitle(const QString& match_title) const;
|
|
bool matchClientMachine(const QByteArray& match_machine, bool local) const;
|
|
void readFromSettings(const RuleSettings *settings);
|
|
static ForceRule convertForceRule(int v);
|
|
static QString getDecoColor(const QString &themeName);
|
|
#ifndef KCMRULES
|
|
static bool checkSetRule(SetRule rule, bool init);
|
|
static bool checkForceRule(ForceRule rule);
|
|
static bool checkSetStop(SetRule rule);
|
|
static bool checkForceStop(ForceRule rule);
|
|
#endif
|
|
int temporary_state; // e.g. for kstart
|
|
QString description;
|
|
QByteArray wmclass;
|
|
StringMatch wmclassmatch;
|
|
bool wmclasscomplete;
|
|
QByteArray windowrole;
|
|
StringMatch windowrolematch;
|
|
QString title;
|
|
StringMatch titlematch;
|
|
QByteArray clientmachine;
|
|
StringMatch clientmachinematch;
|
|
NET::WindowTypes types; // types for matching
|
|
Placement::Policy placement;
|
|
ForceRule placementrule;
|
|
QPoint position;
|
|
SetRule positionrule;
|
|
QSize size;
|
|
SetRule sizerule;
|
|
QSize minsize;
|
|
ForceRule minsizerule;
|
|
QSize maxsize;
|
|
ForceRule maxsizerule;
|
|
int opacityactive;
|
|
ForceRule opacityactiverule;
|
|
int opacityinactive;
|
|
ForceRule opacityinactiverule;
|
|
bool ignoregeometry;
|
|
SetRule ignoregeometryrule;
|
|
int desktop;
|
|
SetRule desktoprule;
|
|
int screen;
|
|
SetRule screenrule;
|
|
QString activity;
|
|
SetRule activityrule;
|
|
NET::WindowType type; // type for setting
|
|
ForceRule typerule;
|
|
bool maximizevert;
|
|
SetRule maximizevertrule;
|
|
bool maximizehoriz;
|
|
SetRule maximizehorizrule;
|
|
bool minimize;
|
|
SetRule minimizerule;
|
|
bool shade;
|
|
SetRule shaderule;
|
|
bool skiptaskbar;
|
|
SetRule skiptaskbarrule;
|
|
bool skippager;
|
|
SetRule skippagerrule;
|
|
bool skipswitcher;
|
|
SetRule skipswitcherrule;
|
|
bool above;
|
|
SetRule aboverule;
|
|
bool below;
|
|
SetRule belowrule;
|
|
bool fullscreen;
|
|
SetRule fullscreenrule;
|
|
bool noborder;
|
|
SetRule noborderrule;
|
|
QString decocolor;
|
|
ForceRule decocolorrule;
|
|
bool blockcompositing;
|
|
ForceRule blockcompositingrule;
|
|
int fsplevel;
|
|
int fpplevel;
|
|
ForceRule fsplevelrule;
|
|
ForceRule fpplevelrule;
|
|
bool acceptfocus;
|
|
ForceRule acceptfocusrule;
|
|
bool closeable;
|
|
ForceRule closeablerule;
|
|
bool autogroup;
|
|
ForceRule autogrouprule;
|
|
bool autogroupfg;
|
|
ForceRule autogroupfgrule;
|
|
QString autogroupid;
|
|
ForceRule autogroupidrule;
|
|
bool strictgeometry;
|
|
ForceRule strictgeometryrule;
|
|
QString shortcut;
|
|
SetRule shortcutrule;
|
|
bool disableglobalshortcuts;
|
|
ForceRule disableglobalshortcutsrule;
|
|
QString desktopfile;
|
|
SetRule desktopfilerule;
|
|
friend QDebug& operator<<(QDebug& stream, const Rules*);
|
|
};
|
|
|
|
#ifndef KCMRULES
|
|
class KWIN_EXPORT RuleBook : public QObject
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
~RuleBook() override;
|
|
WindowRules find(const AbstractClient*, bool);
|
|
void discardUsed(AbstractClient* c, bool withdraw);
|
|
void setUpdatesDisabled(bool disable);
|
|
bool areUpdatesDisabled() const;
|
|
void load();
|
|
void edit(AbstractClient* c, bool whole_app);
|
|
void requestDiskStorage();
|
|
|
|
void setConfig(const KSharedConfig::Ptr &config) {
|
|
m_config = config;
|
|
}
|
|
|
|
private Q_SLOTS:
|
|
void temporaryRulesMessage(const QString&);
|
|
void cleanupTemporaryRules();
|
|
void save();
|
|
|
|
private:
|
|
void deleteAll();
|
|
void initializeX11();
|
|
void cleanupX11();
|
|
QTimer *m_updateTimer;
|
|
bool m_updatesDisabled;
|
|
QList<Rules*> m_rules;
|
|
QScopedPointer<KXMessages> m_temporaryRulesMessages;
|
|
KSharedConfig::Ptr m_config;
|
|
|
|
KWIN_SINGLETON(RuleBook)
|
|
};
|
|
|
|
inline
|
|
bool RuleBook::areUpdatesDisabled() const
|
|
{
|
|
return m_updatesDisabled;
|
|
}
|
|
|
|
inline
|
|
bool Rules::checkSetRule(SetRule rule, bool init)
|
|
{
|
|
if (rule > (SetRule)DontAffect) { // Unused or DontAffect
|
|
if (rule == (SetRule)Force || rule == (SetRule) ApplyNow
|
|
|| rule == (SetRule) ForceTemporarily || init)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
inline
|
|
bool Rules::checkForceRule(ForceRule rule)
|
|
{
|
|
return rule == (ForceRule)Force || rule == (ForceRule) ForceTemporarily;
|
|
}
|
|
|
|
inline
|
|
bool Rules::checkSetStop(SetRule rule)
|
|
{
|
|
return rule != UnusedSetRule;
|
|
}
|
|
|
|
inline
|
|
bool Rules::checkForceStop(ForceRule rule)
|
|
{
|
|
return rule != UnusedForceRule;
|
|
}
|
|
|
|
inline
|
|
WindowRules::WindowRules(const QVector< Rules* >& r)
|
|
: rules(r)
|
|
{
|
|
}
|
|
|
|
inline
|
|
WindowRules::WindowRules()
|
|
{
|
|
}
|
|
|
|
inline
|
|
bool WindowRules::contains(const Rules* rule) const
|
|
{
|
|
return rules.contains(const_cast<Rules *>(rule));
|
|
}
|
|
|
|
inline
|
|
void WindowRules::remove(Rules* rule)
|
|
{
|
|
rules.removeOne(rule);
|
|
}
|
|
|
|
#endif
|
|
|
|
QDebug& operator<<(QDebug& stream, const Rules*);
|
|
|
|
} // namespace
|
|
|
|
Q_DECLARE_OPERATORS_FOR_FLAGS(KWin::Rules::Types)
|
|
|
|
#endif
|