/********************************************************************
 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 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
