options.h

/*****************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
Copyright (C) 1999, 2000 Matthias Ettrich <ettrich@kde.org>
Copyright (C) 2003 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_OPTIONS_H
#define KWIN_OPTIONS_H
 
#include <tqobject.h>
#include <tqfont.h>
#include <tqpalette.h>
#include <tqstringlist.h>
#include <kdecoration_p.h>
 
#include "placement.h"
 
namespace KWinInternal
{
 
class Client;
 
class Options : public KDecorationOptions
    {
    public:
 
        Options();
        ~Options();
 
        virtual unsigned long updateSettings();
 
        enum FocusPolicy { ClickToFocus, FocusFollowsMouse, FocusUnderMouse, FocusStrictlyUnderMouse };
        FocusPolicy focusPolicy;
 
 
        bool clickRaise;
 
        bool autoRaise;
 
        int autoRaiseInterval;
 
        bool delayFocus;
 
        int delayFocusInterval;
 
        bool shadeHover;
 
        int shadeHoverInterval;
 
        enum AltTabStyle { KDE, CDE };
        AltTabStyle altTabStyle;
 
        // whether to see Xinerama screens separately for focus (in Alt+Tab, when activating next client)
        bool separateScreenFocus;
        // whether active Xinerama screen is the one with mouse (or with the active window)
        bool activeMouseScreen;
 
        bool xineramaEnabled;
        bool xineramaPlacementEnabled;
        bool xineramaMovementEnabled;
        bool xineramaMaximizeEnabled;
        bool xineramaFullscreenEnabled;
 
        // number, or -1 = active screen (Workspace::activeScreen())
        int xineramaPlacementScreen;
 
        enum MoveResizeMode { Transparent, Opaque };
 
        MoveResizeMode moveMode;
        MoveResizeMode resizeMode;
        MoveResizeMode tilingMode;
 
        static MoveResizeMode stringToMoveResizeMode( const TQString& s );
        static const char* moveResizeModeToString( MoveResizeMode mode );
 
        Placement::Policy placement;
 
        bool focusPolicyIsReasonable()
            {
            return focusPolicy == ClickToFocus || focusPolicy == FocusFollowsMouse;
            }
 
        bool animateShade;
 
        int borderSnapZone;
 
        int windowSnapZone;
 
 
        bool snapOnlyWhenOverlapping;
 
        bool  animateMinimize;
 
        int animateMinimizeSpeed;
 
        bool showDesktopIsMinimizeAll;
 
        bool rollOverDesktops;
 
        // 0 - 4 , see Workspace::allowClientActivation()
        int focusStealingPreventionLevel;
 
        TQStringList ignorePositionClasses;
 
        bool checkIgnoreFocusStealing( const Client* c );
 
        WindowOperation operationTitlebarDblClick() { return OpTitlebarDblClick; }
 
        enum MouseCommand
            {
            MouseRaise, MouseLower, MouseOperationsMenu, MouseToggleRaiseAndLower,
            MouseActivateAndRaise, MouseActivateAndLower, MouseActivate,
            MouseActivateRaiseAndPassClick, MouseActivateAndPassClick,
            MouseMove, MouseUnrestrictedMove,
            MouseActivateRaiseAndMove, MouseActivateRaiseAndUnrestrictedMove,
            MouseResize, MouseUnrestrictedResize,
            MouseShade, MouseSetShade, MouseUnsetShade,
            MouseMaximize, MouseRestore, MouseMinimize,
            MouseNextDesktop, MousePreviousDesktop,
            MouseAbove, MouseBelow,
            MouseOpacityMore, MouseOpacityLess,
            MouseNothing
            };
 
        enum MouseWheelCommand
            {
            MouseWheelRaiseLower, MouseWheelShadeUnshade, MouseWheelMaximizeRestore,
            MouseWheelAboveBelow, MouseWheelPreviousNextDesktop,
            MouseWheelChangeOpacity,
            MouseWheelNothing
            };
 
        MouseCommand operationTitlebarMouseWheel( int delta )
            {
            return wheelToMouseCommand( CmdTitlebarWheel, delta, CmdTitlebarRevWheel );
            }
        MouseCommand operationWindowMouseWheel( int delta )
            {
            return wheelToMouseCommand( CmdAllWheel, delta, CmdAllRevWheel );
            }
 
        MouseCommand commandActiveTitlebar1() { return CmdActiveTitlebar1; }
        MouseCommand commandActiveTitlebar2() { return CmdActiveTitlebar2; }
        MouseCommand commandActiveTitlebar3() { return CmdActiveTitlebar3; }
        MouseCommand commandInactiveTitlebar1() { return CmdInactiveTitlebar1; }
        MouseCommand commandInactiveTitlebar2() { return CmdInactiveTitlebar2; }
        MouseCommand commandInactiveTitlebar3() { return CmdInactiveTitlebar3; }
        MouseCommand commandWindow1() { return CmdWindow1; }
        MouseCommand commandWindow2() { return CmdWindow2; }
        MouseCommand commandWindow3() { return CmdWindow3; }
        MouseCommand commandAll1() { return CmdAll1; }
        MouseCommand commandAll2() { return CmdAll2; }
        MouseCommand commandAll3() { return CmdAll3; }
        uint keyCmdAllModKey() { return CmdAllModKey; }
 
 
        static WindowOperation windowOperation(const TQString &name, bool restricted );
        static MouseCommand mouseCommand(const TQString &name, bool restricted );
        static MouseWheelCommand mouseWheelCommand(const TQString &name);
 
        bool showGeometryTip();
 
        bool resetMaximizedWindowGeometry();
 
        TQColor &shadowColour(bool active=true);
 
        bool shadowWindowType(NET::WindowType t);
 
        bool shadowEnabled(bool active=true);
 
        double shadowOpacity(bool active=true);
 
        int shadowThickness(bool active=true);
 
        int shadowXOffset(bool active=true);
 
        int shadowYOffset(bool active=true);
 
        enum { ActiveDisabled = 0,
               ActiveSwitchOnMove = 1,
               ActiveSwitchAlways = 2,
               ActiveTileOnly = 3,
               ActiveTileMaximize = 4 };
        int activeBorders();
 
        int borderActivationDistance();
 
        int activeBorderDelay();
 
        bool topMenuEnabled() const { return topmenus; }
        bool desktopTopMenu() const { return desktop_topmenu; }
 
        // timeout before non-responding application will be killed after attempt to close
        int killPingTimeout;
 
        // Whether to hide utility windows for inactive applications.
        bool hideUtilityWindowsForInactive;
 
        //translucency settings
        bool useTranslucency;
        bool translucentActiveWindows;
        uint activeWindowOpacity;
        bool translucentInactiveWindows;
        uint inactiveWindowOpacity;
        bool translucentMovingWindows;
        uint movingWindowOpacity;
        bool removeShadowsOnResize;
        bool removeShadowsOnMove;
        bool translucentDocks;
        uint dockOpacity;
        bool keepAboveAsActive;
        bool useTitleMenuSlider;
        uint activeWindowShadowSize;
        uint inactiveWindowShadowSize;
        uint dockShadowSize;
        uint menuShadowSize;
        bool onlyDecoTranslucent;
        bool resetKompmgr;
        bool tabboxOutline;
 
    private:
        WindowOperation OpTitlebarDblClick;
 
    // mouse bindings
        MouseCommand CmdActiveTitlebar1;
        MouseCommand CmdActiveTitlebar2;
        MouseCommand CmdActiveTitlebar3;
        MouseCommand CmdInactiveTitlebar1;
        MouseCommand CmdInactiveTitlebar2;
        MouseCommand CmdInactiveTitlebar3;
        MouseWheelCommand CmdTitlebarWheel;
        bool CmdTitlebarRevWheel;
        MouseCommand CmdWindow1;
        MouseCommand CmdWindow2;
        MouseCommand CmdWindow3;
        MouseCommand CmdAll1;
        MouseCommand CmdAll2;
        MouseCommand CmdAll3;
        MouseWheelCommand CmdAllWheel;
        bool CmdAllRevWheel;
        uint CmdAllModKey;
 
        int active_borders;
        int active_border_delay;
        int active_border_distance;
        bool show_geometry_tip;
        bool reset_maximized_window_geometry;
        bool topmenus;
        bool desktop_topmenu;
        TQColor shadow_colour;
        TQColor shadow_inactive_colour;
        bool shadow_docks;
        bool shadow_menus;
        bool shadow_overrides;
        bool shadow_topMenus;
        bool shadow_inactive_enabled;
        bool shadow_enabled;
        double shadow_inactive_opacity;
        double shadow_opacity;
        int shadow_inactive_thickness;
        int shadow_thickness;
        int shadow_inactive_x_offset;
        int shadow_x_offset;
        int shadow_inactive_y_offset;
        int shadow_y_offset;
        // List of window classes for which not to use focus stealing prevention
        TQStringList ignoreFocusStealingClasses;
 
        MouseCommand wheelToMouseCommand( MouseWheelCommand com, int delta, bool revDir );
    };
 
extern Options* options;
 
} // namespace
 
#endif