kwin/rules.h
Vlad Zagorodniy 8af2fa73dc 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 20:03:22 +03:00

394 lines
13 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 <kconfiggroup.h>
#include "placement.h"
#include "options.h"
#include "utils.h"
class QDebug;
class KConfig;
class KXMessages;
namespace KWin
{
class AbstractClient;
class Client;
class Rules;
#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 KConfigGroup&);
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
};
void write(KConfigGroup&) 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;
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 readFromCfg(const KConfigGroup& cfg);
static SetRule readSetRule(const KConfigGroup&, const QString& key);
static ForceRule readForceRule(const KConfigGroup&, const QString& key);
static NET::WindowType readType(const KConfigGroup&, const QString& key);
static QString readDecoColor(const KConfigGroup &cfg);
#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 initWithX11();
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