Rename kwin to twin (Part 2 of 2)

1 files changed, 311 insertions, 0 deletions

diff --git a/twin/rules.h b/twin/rules.h
new file mode 100644
index 000000000..061f0ce80
--- /dev/null
+++ b/twin/rules.h
@@ -0,0 +1,311 @@
+/*****************************************************************
+ KWin - the KDE window manager
+ This file is part of the KDE project.
+
+Copyright (C) 2004 Lubos Lunak <l.lunak@kde.org>
+
+You can Freely distribute this program under the GNU General Public
+License. See the file "COPYING" for the exact licensing terms.
+******************************************************************/
+
+#ifndef KWIN_RULES_H
+#define KWIN_RULES_H
+
+#include <tqstring.h>
+#include <netwm_def.h>
+#include <tqrect.h>
+#include <tqvaluevector.h>
+#include <kdebug.h>
+
+#include "placement.h"
+#include "lib/kdecoration.h"
+#include "options.h"
+#include "utils.h"
+
+class KConfig;
+
+namespace KWinInternal
+{
+
+class Client;
+class Rules;
+
+#ifndef KCMRULES // only for twin core
+
+class WindowRules
+    : public KDecorationDefines
+    {
+    public:
+        WindowRules( const TQValueVector< Rules* >& rules );
+        WindowRules();
+        void update( Client* );
+        void discardTemporary();
+        bool contains( const Rules* rule ) const;
+        void remove( Rules* rule );
+        Placement::Policy checkPlacement( Placement::Policy placement ) const;
+        TQRect checkGeometry( TQRect rect, bool init = false ) const;
+        // use 'invalidPoint' with checkPosition, unlike TQSize() and TQRect(), TQPoint() is a valid point
+        TQPoint checkPosition( TQPoint pos, bool init = false ) const;
+        TQSize checkSize( TQSize s, bool init = false ) const;
+        TQSize checkMinSize( TQSize s ) const;
+        TQSize checkMaxSize( TQSize s ) const;
+        int checkOpacityActive(int s) const;
+        int checkOpacityInactive(int s) const;
+        bool checkIgnoreGeometry( bool ignore ) const;
+        int checkDesktop( int desktop, 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 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;
+        int checkFSP( int fsp ) const;
+        bool checkAcceptFocus( bool focus ) const;
+        Options::MoveResizeMode checkMoveResizeMode( Options::MoveResizeMode mode ) const;
+        bool checkCloseable( bool closeable ) const;
+        bool checkStrictGeometry( bool strict ) const;
+        TQString checkShortcut( TQString s, bool init = false ) const;
+        bool checkDisableGlobalShortcuts( bool disable ) const;
+        bool checkIgnorePosition( bool ignore ) const; // obsolete
+    private:
+        MaximizeMode checkMaximizeVert( MaximizeMode mode, bool init ) const;
+        MaximizeMode checkMaximizeHoriz( MaximizeMode mode, bool init ) const;
+        TQValueVector< Rules* > rules;
+    };
+#endif
+
+class Rules
+    : public KDecorationDefines
+    {
+    public:
+        Rules();
+        Rules( KConfig& );
+        Rules( const TQString&, bool temporary );
+        void write( KConfig& ) const;
+        bool isEmpty() const;
+#ifndef KCMRULES
+        void discardUsed( bool withdrawn );
+        bool match( const Client* c ) const;
+        bool update( Client* );
+        bool isTemporary() const;
+        bool discardTemporary( bool force ); // removes if temporary and forced or too old
+        bool applyPlacement( Placement::Policy& placement ) const;
+        bool applyGeometry( TQRect& rect, bool init ) const;
+        // use 'invalidPoint' with applyPosition, unlike TQSize() and TQRect(), TQPoint() is a valid point
+        bool applyPosition( TQPoint& pos, bool init ) const;
+        bool applySize( TQSize& s, bool init ) const;
+        bool applyMinSize( TQSize& s ) const;
+        bool applyMaxSize( TQSize& s ) const;
+        bool applyOpacityActive(int& s) const;
+        bool applyOpacityInactive(int& s) const;
+        bool applyIgnoreGeometry( bool& ignore ) const;
+        bool applyDesktop( int& desktop, 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 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 applyFSP( int& fsp ) const;
+        bool applyAcceptFocus( bool& focus ) const;
+        bool applyMoveResizeMode( Options::MoveResizeMode& mode ) const;
+        bool applyCloseable( bool& closeable ) const;
+        bool applyStrictGeometry( bool& strict ) const;
+        bool applyShortcut( TQString& shortcut, bool init ) const;
+        bool applyDisableGlobalShortcuts( bool& disable ) const;
+        bool applyIgnorePosition( bool& ignore ) const; // obsolete
+    private:
+#endif
+        bool matchType( NET::WindowType match_type ) const;
+        bool matchWMClass( const TQCString& match_class, const TQCString& match_name ) const;
+        bool matchRole( const TQCString& match_role ) const;
+        bool matchTitle( const TQString& match_title ) const;
+        bool matchClientMachine( const TQCString& match_machine ) const;
+        // 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 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
+            };
+        enum StringMatch
+            {
+            FirstStringMatch,
+            UnimportantMatch = FirstStringMatch,
+            ExactMatch,
+            SubstringMatch,
+            RegExpMatch,
+            LastStringMatch = RegExpMatch
+            };
+        void readFromCfg( KConfig& cfg );
+        static SetRule readSetRule( KConfig&, const TQString& key );
+        static ForceRule readForceRule( KConfig&, const TQString& key );
+        static NET::WindowType readType( KConfig&, const TQString& key );
+#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
+        TQString description;
+        TQCString wmclass;
+        StringMatch wmclassmatch;
+        bool wmclasscomplete;
+        TQCString windowrole;
+        StringMatch windowrolematch;
+        TQString title; // TODO "caption" ?
+        StringMatch titlematch;
+        TQCString extrarole;
+        StringMatch extrarolematch;
+        TQCString clientmachine;
+        StringMatch clientmachinematch;
+        unsigned long types; // types for matching
+        Placement::Policy placement;
+        ForceRule placementrule;
+        TQPoint position;
+        SetRule positionrule;
+        TQSize size;
+        SetRule sizerule;
+        TQSize minsize;
+        ForceRule minsizerule;
+        TQSize maxsize;
+        ForceRule maxsizerule;
+        int opacityactive;
+        ForceRule opacityactiverule;
+        int opacityinactive;
+        ForceRule opacityinactiverule;
+        bool ignoreposition;
+        ForceRule ignorepositionrule;
+        int desktop;
+        SetRule desktoprule;
+        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 above;
+        SetRule aboverule;
+        bool below;
+        SetRule belowrule;
+        bool fullscreen;
+        SetRule fullscreenrule;
+        bool noborder;
+        SetRule noborderrule;
+        int fsplevel;
+        ForceRule fsplevelrule;
+        bool acceptfocus;
+        ForceRule acceptfocusrule;
+        Options::MoveResizeMode moveresizemode;
+        ForceRule moveresizemoderule;
+        bool closeable;
+        ForceRule closeablerule;
+        bool strictgeometry;
+        ForceRule strictgeometryrule;
+        TQString shortcut;
+        SetRule shortcutrule;
+        bool disableglobalshortcuts;
+        ForceRule disableglobalshortcutsrule;
+        friend kdbgstream& operator<<( kdbgstream& stream, const Rules* );
+    };
+
+#ifndef KCMRULES
+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 TQValueVector< Rules* >& r )
+    : rules( r )
+    {
+    }
+
+inline
+WindowRules::WindowRules()
+    {
+    }
+
+inline
+bool WindowRules::contains( const Rules* rule ) const
+    {
+    return tqFind( rules.begin(), rules.end(), rule ) != rules.end();
+    }
+    
+inline
+void WindowRules::remove( Rules* rule )
+    {
+    TQValueVector< Rules* >::Iterator pos = tqFind( rules.begin(), rules.end(), rule );
+    if( pos != rules.end())
+        rules.erase( pos );
+    }
+
+#endif
+
+#ifdef NDEBUG
+inline
+kndbgstream& operator<<( kndbgstream& stream, const Rules* ) { return stream; }
+#else
+kdbgstream& operator<<( kdbgstream& stream, const Rules* );
+#endif
+
+} // namespace
+
+#endif