kstyle.h

Go to the documentation of this file.

#ifndef KDE_KSTYLE_H
#define KDE_KSTYLE_H

#include <kdeui_export.h>

#include <QtGui/QCommonStyle>
#include <QtGui/QPalette>
#include <QtGui/QStylePlugin>
#include <typeinfo>

class QStyleOptionProgressBar;
class QStyleOptionTab;

class KStylePrivate;
// TODO: From 'Qt4 Themes' discussion on kde-devel
// - Remi Villatel: extend QStyle enums for KColorButton, KColorCombo, KKeyButton, split PE_HeaderSection into KPopupTitle, PopupMenuTitle, TaskContainer)
// - RV: KLineEdit "plays with its colors" - related to KStyle?
// - RV: KMulitTabBarTab ... does it need support from KStyle (instead of manual button rotation etc.)? Or is it dumped already?
// - RV: KTabCtl draws itself mimicking QDrawShadeThingies
// - RV: fixed colors (e.g. Konqueror, KToolbarButton label text ->KPE_ToolbarButton?): To prevent hacks like "preventing any PaletteChange()"... mor related to KDE4 color schemes... I guess
// - LM: User interface guidelines... related to KStyle?
// - e.g. drawFancyPE() in kdeui for KDE widgets: check "qobject_cast<KStyle*>(style())", or fallback drawing...
// TODO: implement standardIcon().. and what about standardPalette()?
// TODO: maybe the arrow in CE_PushButtonLabel should be painted in CE_PushButtonBevel like QCommonStyle

class KDEUI_EXPORT KStyle: public QCommonStyle
{
    Q_OBJECT

public:
    KStyle();
    ~KStyle();

    static QString defaultStyle();
     static StyleHint customStyleHint(const QString &element, const QWidget *widget);
     static ControlElement customControlElement(const QString &element, const QWidget *widget);
     static SubElement customSubElement(const QString &element, const QWidget *widget);

protected:

    StyleHint newStyleHint(const QString &element);
    ControlElement newControlElement(const QString &element);
    SubElement newSubElement(const QString &element);
    
    void drawInsideRect(QPainter* p, const QRect& r) const;
    
    QRect centerRect(const QRect &in, int w, int h) const;

    QRect centerRect(const QRect &in, const QSize &size) const;

    class KDEUI_EXPORT ColorMode //krazy:exclude=dpointer (lightweight helper)
    {
    public:
        enum Mode
        {
            PaletteEntryMode,
            BWAutoContrastMode = 0x8000000
        };
    private:
        Mode                mode;
        QPalette::ColorRole role;
    public:

        ColorMode(QPalette::ColorRole _role);

        ColorMode(Mode _mode, QPalette::ColorRole _role);

        operator int() const;

        ColorMode(int encoded);

        QColor color(const QPalette& palette);
    };

    
    struct KDEUI_EXPORT Option
    {
        virtual ~Option() {} //So dynamic_cast works, and g++ shuts up
    };

    template<typename EventualSubtype, typename BaseType>
    struct KDEUI_EXPORT OptionBase: public BaseType
    {
        static EventualSubtype* defaultOption()
        {
            static EventualSubtype* theDefault = 0; //### function static, not very nice,
            //but avoids need for explicit instantiation.

            if (!theDefault)
                theDefault = new EventualSubtype;
                
            return theDefault;
        }
    };
    
    template<typename T>
    static T extractOption(Option* option);

    struct KDEUI_EXPORT ColorOption: public OptionBase<ColorOption, Option>
    {
        ColorMode color;

        ColorOption(): color(QPalette::ButtonText)
        {}
    };

    struct KDEUI_EXPORT IconOption: public OptionBase<IconOption, Option>
    {
        bool  active; 
        QIcon icon;   
        QSize size;

        IconOption(): active(false)
        {}
    };

    struct KDEUI_EXPORT DoubleButtonOption: public OptionBase<DoubleButtonOption, Option>
    {
        enum ActiveButton
        {
            None,   
            Top,    
            Left,   
            Right,  
            Bottom  
        };

        ActiveButton activeButton; 

        DoubleButtonOption(): activeButton(None)
        {}

        DoubleButtonOption(ActiveButton ab): activeButton(ab)
        {}
    };

    struct KDEUI_EXPORT TitleButtonOption: public OptionBase<TitleButtonOption, Option>
    {
        bool active;  
        QIcon icon;   
//         /// whether the button is hovered, this doesn't work at the moment (not even in any Qt style)...
//         bool hover;

        TitleButtonOption(): active(false)/*, hover(false)*/
        {}

        TitleButtonOption(bool act): active(act)
        {}
    };
    
    struct KDEUI_EXPORT TextOption: public OptionBase<TextOption, ColorOption>
    {
        Qt::Alignment        hAlign; 
        QString              text;   
        
        TextOption();

        TextOption(const QString& _text);

        void init();
    };

    enum WidgetType
    {
        WT_Generic,         
        WT_PushButton,      
        WT_Splitter,        
        WT_CheckBox,        
        WT_RadioButton,     
        WT_DockWidget,      
        WT_ProgressBar,     
        WT_MenuBar,         
        WT_MenuBarItem,     
        WT_Menu,            
        WT_MenuItem,        
        WT_ScrollBar,       
        WT_TabBar,          
        WT_TabWidget,       
        WT_Slider,          
        WT_Tree,            
        WT_SpinBox,         
        WT_ComboBox,        
        WT_Header,          
        WT_LineEdit,        
        WT_GroupBox,        
        WT_StatusBar,       
        WT_ToolBar,         
        WT_ToolButton,      
        WT_ToolBoxTab,      
        WT_Window,          
        WT_Limit = 0xFFFF 
    };

                
    enum MarginOffsets
    {
        MainMargin, 
        Top,        
        Bot,        
        Left,       
        Right,      
        MarginInc   
    };


    struct Generic
    {
        enum LayoutProp
        {
            DefaultFrameWidth,    
            DefaultLayoutSpacing, 
            DefaultLayoutMargin   
        };

        enum Primitive
        {
            Text = 0xFFFF,  
            Icon,           
            FocusIndicator, 
            Frame,          
            ArrowUp,        
            ArrowDown,      
            ArrowRight,     
            ArrowLeft       
        };
    };

    struct PushButton
    {
        enum LayoutProp
        {
            ContentsMargin, 
            FocusMargin            = ContentsMargin + MarginInc, 
            DefaultIndicatorMargin = FocusMargin    + MarginInc, 
            PressedShiftHorizontal = DefaultIndicatorMargin + MarginInc, 
            PressedShiftVertical, 
            MenuIndicatorSize, 
            TextToIconSpace 
        };

        enum Primitive
        {
            Panel,              
            DefaultButtonFrame  
        };
    };

    struct Splitter
    {
        enum LayoutProp
        {
            Width 
        };

        enum Primitive
        {
            HandleHor,      
            HandleVert      
        };
    };

    struct CheckBox
    {
        enum LayoutProp
        {
            Size,               
            BoxTextSpace,       
            NoLabelFocusMargin, 
            FocusMargin = NoLabelFocusMargin + MarginInc 
        };

        enum Primitive
        {
            CheckOn,        
            CheckOff,       
            CheckTriState   
        };
    };

    struct RadioButton
    {
        enum LayoutProp
        {
            Size, 
            BoxTextSpace, 
            FocusMargin   
        };

        enum Primitive
        {
            RadioOn,        
            RadioOff        
        };
    };
    

    struct DockWidget
    {
        enum LayoutProp
        {
            TitleTextColor, 
            TitleMargin, 
            FrameWidth = TitleMargin + MarginInc,  
            SeparatorExtent 
        };

        enum Primitive
        {
            TitlePanel, 
            SeparatorHandle 
        };
    };

    struct ProgressBar
    {
        enum LayoutProp
        {
            GrooveMargin,        
            SideText = GrooveMargin + MarginInc, 
            SideTextSpace,       
            Precision,           
            BusyIndicatorSize,   
            MaxBusyIndicatorSize 
        };

        enum Primitive
        {
            Groove,         
            Indicator,      
            BusyIndicator   
        };
    };


    struct MenuBar
    {
        enum LayoutProp
        {
            Margin,           
            ItemSpacing = Margin + MarginInc 
        };

        enum Property
        {
            EmptyArea 
        };
    };


    struct MenuBarItem
    {
        enum LayoutProp
        {
            Margin,                    
            Dummy = Margin + MarginInc //Paranoia about underlying type
        };

        enum Primitive
        {
            Panel       
        };
    };

    struct Menu
    {
        enum LayoutProp
        {
            FrameWidth, 
            Margin,     
            ScrollerHeight = Margin + MarginInc, 
            TearOffHeight 
        };

        enum Primitive
        {
            Background, 
            TearOff,    
            Scroller    
        };
    };

    struct MenuItem
    {
        enum LayoutProp
        {
            Margin,         
            CheckAlongsideIcon = Margin + MarginInc,
            CheckWidth,     
            CheckSpace,     
            IconWidth,      
            IconSpace,      
            AccelSpace,     
            ArrowSpace,     
            ArrowWidth,     
            SeparatorHeight,
            MinHeight,      
            ActiveTextColor,
            TextColor,      
            DisabledTextColor, 
            ActiveDisabledTextColor 
        };

        enum Primitive
        {
            CheckColumn, 
            CheckOn,     
            CheckOff,    
            RadioOn,     
            RadioOff,    
            CheckIcon,   
            Separator,   //A separator item.
            ItemIndicator //Shows the active item
        };
    };


    struct ScrollBar
    {
        enum LayoutProp
        {
            DoubleTopButton,    
            DoubleBotButton,    
            SingleButtonHeight, 
            DoubleButtonHeight, 
            BarWidth,           
            MinimumSliderHeight,
            ArrowColor,         
            ActiveArrowColor    
        };

        enum Primitive
        {
            SingleButtonVert,   
            SingleButtonHor,    
            DoubleButtonVert,           
            DoubleButtonHor,            
            GrooveAreaVertBottom,   
            GrooveAreaHorRight,    
            GrooveAreaVertTop,   
            GrooveAreaHorLeft,    
            SliderVert,       
            SliderHor         
        };
    };

    struct TabBar
    {
        enum LayoutProp
        {
            TabContentsMargin,  
            TabFocusMargin     = TabContentsMargin + MarginInc,
            TabTextToIconSpace = TabFocusMargin    + MarginInc,
            TabOverlap,         
            BaseHeight,        
            BaseOverlap,       
            ScrollButtonWidth  
        };

        enum Primitive
        {
            EastText,       
            WestText,       
            NorthTab,       
            EastTab,
            WestTab,
            SouthTab,
            BaseFrame,      
            IndicatorTear   
        };
    };

    struct TabWidget
    {
        enum LayoutProp
        {
            ContentsMargin,      
            DummyProp = ContentsMargin+MarginInc
        };
    };

    struct Slider
    {

        enum LayoutProp
        {
            HandleThickness, 
            HandleLength     
        };

        enum Primitive
        {
            HandleVert,   
            HandleHor,    
            GrooveVert,   
            GrooveHor     
        };
    };


    struct Tree
    {
        enum LayoutProp
        {
            MaxExpanderSize      
        };

        enum Primitive
        {
            ExpanderClosed, 
            ExpanderOpen,   
            HorizontalBranch, 
            VerticalBranch    
        };
    };

    struct SpinBox
    {
        enum LayoutProp
        {
            FrameWidth,        
            ButtonWidth,       
            ButtonMargin,      
            ButtonSpacing = ButtonMargin + MarginInc, 
            SymmetricButtons,  
            SupportFrameless,   
            ContentsMargin
        };

        enum Primitive
        {
            EditField,          
            UpButton,           
            DownButton,         
            ButtonArea,         
            PlusSymbol,         
            MinusSymbol         
        };
    };

    struct ComboBox
    {
        enum LayoutProp
        {
            FrameWidth,         
            ButtonWidth,        
            ButtonMargin,       
            FocusMargin = ButtonMargin + MarginInc,
            SupportFrameless = FocusMargin + MarginInc,
            ContentsMargin
        };

        enum Primitive
        {
            EditField,          
            Button              
        };
    };

    struct Header
    {
        enum LayoutProp
        {
            ContentsMargin,      
            TextToIconSpace = ContentsMargin + MarginInc,
            MarkSize             
        };

        enum Primitive
        {
            SectionHor, 
            SectionVert 
        };
    };

    struct LineEdit
    {
        enum Primitive
        {
            Panel     
        };
    };

    struct GroupBox
    {
        enum LayoutProps
        {
            FrameWidth, 
            TextAlignTop, 
            TitleTextColor 
        };
        enum Primitive
        {
            FlatFrame  
        };
    };

    struct StatusBar
    {
    };

    struct ToolBar
    {
        enum LayoutProps
        {
            HandleExtent,       
            SeparatorExtent,    
            ExtensionExtent,    
            FrameWidth,    
            ItemMargin,         
            ItemSpacing         
        };

        enum Primitive
        {
            HandleHor, 
            HandleVert, 
            Separator, 
            PanelHor,  
            PanelVert  
        };
    };


    struct ToolBoxTab
    {
        enum LayoutProps
        {
            Margin  
        };

        enum Primitive
        {
            Panel   
        };
    };


    struct ToolButton
    {
        enum LayoutProps
        {
            ContentsMargin,  
            FocusMargin            = ContentsMargin + MarginInc,
            MenuIndicatorSize, 
            InlineMenuIndicatorSize = FocusMargin + MarginInc, 
            InlineMenuIndicatorXOff,  
            InlineMenuIndicatorYOff   
        };

        enum Primitive
        {
            Panel           
        };
    };


    struct Window
    {
        enum LayoutProps
        {
            TitleTextColor, 
            TitleHeight, 
            NoTitleFrame, 
            TitleMargin,  
            ButtonWidth = TitleMargin + MarginInc, 
            ButtonSpace,      
            ButtonToTextSpace 
        };

        enum Primitive
        {
            TitlePanel,  
            ButtonMenu,     
            ButtonMin,      
            ButtonMax,      
            ButtonRestore,  
            ButtonClose,    
            ButtonShade,    
            ButtonUnshade,  
            ButtonHelp      
        };
    };

    void setWidgetLayoutProp(WidgetType widget, int metric, int value);

    virtual int widgetLayoutProp(WidgetType widgetType, int metric,
                                 const QStyleOption* opt = 0, const QWidget* w = 0) const;

    virtual void drawKStylePrimitive(WidgetType widgetType, int primitive, 
                                     const QStyleOption* opt,
                                     const QRect &r, const QPalette &pal,
                                     State flags, QPainter* p,
                                     const QWidget* widget = 0,
                                     Option* kOpt    = 0) const;
private:
    bool useSideText(const QStyleOptionProgressBar* opt)     const;
    int  sideTextWidth(const QStyleOptionProgressBar* pbOpt) const;

    bool isVerticalTab (const QStyleOptionTab* tbOpt) const;

    bool isReflectedTab(const QStyleOptionTab* tbOpt) const;

    enum Side
    {
        North,
        East,
        West,
        South
    };

    Side tabSide(const QStyleOptionTab* tbOpt) const;

    QRect marginAdjustedTab(const QStyleOptionTab* tbOpt, int property) const;

    QRect  handleRTL(const QStyleOption* opt, const QRect& subRect) const;
    QPoint handleRTL(const QStyleOption* opt, const QPoint& pos)    const;

    QVector<QVector<int> > metrics;
    
    QSize expandDim(const QSize& orig, WidgetType widget, int baseMarginMetric, const QStyleOption* opt, const QWidget* w, bool rotated = false) const;
    
    QRect insideMargin(const QRect &orig, WidgetType widget, int baseMarginMetric, const QStyleOption* opt, const QWidget* w) const;

    QRect internalSubControlRect (ComplexControl control, const QStyleOptionComplex* opt,
                                                    SubControl subControl, const QWidget* w) const;

    // fitt's law label support: QLabel focusing its buddy widget
    const QObject *clickedLabel;

    template<typename T>
    static T extractOptionHelper(T*);

public:
    void drawControl      (ControlElement   elem, const QStyleOption* opt, QPainter* p, const QWidget* w) const;
    void drawPrimitive    (PrimitiveElement elem, const QStyleOption* opt, QPainter* p, const QWidget* w) const;
    int  pixelMetric      (PixelMetric    metric, const QStyleOption* opt = 0, const QWidget* w = 0) const;
    QRect subElementRect  (SubElement    subRect, const QStyleOption* opt, const QWidget* w) const;
    QSize sizeFromContents(ContentsType     type, const QStyleOption* opt,
                                                const QSize& contentsSize, const QWidget* w) const;
    int   styleHint       (StyleHint        hint, const QStyleOption* opt, const QWidget* w,
                                                               QStyleHintReturn* returnData) const;
    QRect subControlRect (ComplexControl control, const QStyleOptionComplex* opt,
                                                    SubControl subControl, const QWidget* w) const;
    SubControl hitTestComplexControl(ComplexControl cc, const QStyleOptionComplex* opt,
                                             const QPoint& pt, const QWidget* w) const;
    void       drawComplexControl   (ComplexControl cc, const QStyleOptionComplex* opt,
                                             QPainter *p,      const QWidget* w) const;

    void polish(QWidget *);
    void unpolish(QWidget *);
    void polish(QApplication *);
    void unpolish(QApplication *);
    void polish(QPalette &);
    QRect itemTextRect(const QFontMetrics &fm, const QRect &r,
                           int flags, bool enabled,
                           const QString &text) const;
    QRect itemPixmapRect(const QRect &r, int flags, const QPixmap &pixmap) const;
    void drawItemText(QPainter *painter, const QRect &rect,
                              int flags, const QPalette &pal, bool enabled,
                              const QString &text, QPalette::ColorRole textRole = QPalette::NoRole) const;
    void drawItemPixmap(QPainter *painter, const QRect &rect,
                                int alignment, const QPixmap &pixmap) const;
    QPalette standardPalette() const;
    QPixmap standardPixmap(StandardPixmap standardPixmap, const QStyleOption *opt,
                                   const QWidget *widget = 0) const; //### kde5 remove
    QPixmap generatedIconPixmap(QIcon::Mode iconMode, const QPixmap &pixmap,
                                   const QStyleOption *opt) const;
    bool eventFilter(QObject *, QEvent *);

protected Q_SLOTS:
    int layoutSpacingImplementation(QSizePolicy::ControlType control1,
                    QSizePolicy::ControlType control2, Qt::Orientation orientation,
                    const QStyleOption *option, const QWidget *widget) const;

    QIcon standardIconImplementation(StandardPixmap standardIcon, const QStyleOption *option = 0,
                                     const QWidget *widget = 0) const;
private:
    KStylePrivate * const d;
};

template<typename T>
const char* kstyleName()
{ return "default"; }

template<typename T>
class KStyleFactory: public QStylePlugin
{
    QStringList keys() const
    {
        QStringList l;
        l << kstyleName<T>();
        return l;
    }
    
    QStyle* create(const QString& id)
    {
        QStringList names = keys();
        //check whether included in the keys
        if (names.contains(id, Qt::CaseInsensitive))
            return new T();

        return 0;
    }
};

// get the pointed-to type from a pointer
template<typename T>
T KStyle::extractOptionHelper(T*)
{
    return T();
}

template<typename T>
T KStyle::extractOption(Option* option)
{
    if (option) {
        if (dynamic_cast<T>(option))
            return static_cast<T>(option);
        // Ugly hacks for when RTLD_GLOBAL is not used (quite common with plugins, really)
        // and dynamic_cast fails.
        // This is still partially broken as it doesn't take into account subclasses.
        // ### KDE5 do this somehow differently
        if ( qstrcmp(typeid(*option).name(), typeid(extractOptionHelper(static_cast<T>(0))).name()) == 0 )
            return static_cast<T>(option);
    }

    //### warn if cast failed?

    //since T is a pointer type, need this to get to the static.
    return static_cast<T>(0)->defaultOption();
}

#define K_EXPORT_STYLE(name,type) template<> const char* kstyleName<type>() { return name; } \
    Q_EXPORT_PLUGIN(KStyleFactory<type>)

#endif
// kate: indent-width 4; replace-tabs on; tab-width 4; space-indent on;