othemebase.h

Go to the documentation of this file.

/* This file is part of the KDE libraries
  Copyright (C) 1999 Daniel M. Duley <mosfet@kde.org>

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Library General Public
  License version 2 as published by the Free Software Foundation.

  This library 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
  Library General Public License for more details.

  You should have received a copy of the GNU Library General Public License
  along with this library; see the file COPYING.LIB.  If not, write to
  the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  Boston, MA 02111-1307, USA.
*/
#ifndef __OTHEMEBASE_H
#define __OTHEMEBASE_H

/* OPIE */
#include <opie2/odebug.h>
using namespace Opie::Core;

/* QT */
#include <qdatetime.h>
#include <qtimer.h>
#include <qwindowsstyle.h>
#include <qpixmap.h>
#include <qpe/config.h>
#include <qimage.h>
#include <qintcache.h>
#include <qstring.h>
#include <qpalette.h>

#define WIDGETS 54

class OThemePixmap : public QPixmap
{
public:
    enum BorderType{Top = 0, Bottom, Left, Right, TopLeft, TopRight, BottomLeft,
                    BottomRight};

    OThemePixmap( bool timer = true );
    OThemePixmap( const OThemePixmap &p );
    ~OThemePixmap();
    QPixmap* border( BorderType type );
    void setBorder( BorderType type, const QPixmap &p );
    void updateAccessed();
    bool isOld();
protected:
    QTime *t;
    QPixmap *b[ 8 ];

private:
    class OThemePixmapPrivate;
    OThemePixmapPrivate *d;
};

inline QPixmap* OThemePixmap::border( BorderType type )
{
    return ( b[ type ] );
}

inline void OThemePixmap::setBorder( BorderType type, const QPixmap &p )
{
    if ( b[ type ] ) {
        owarn << "OThemePixmap: Overwriting existing border!" << oendl;
        delete( b[ type ] );
    }
    b[ type ] = new QPixmap( p );
}

inline void OThemePixmap::updateAccessed()
{
    if (t)
        t->start();
}

inline bool OThemePixmap::isOld()
{
    return ( t ? t->elapsed() >= 300000 : false );
}

class OThemeCache : public QObject
{
    Q_OBJECT
public:
    enum ScaleHint{FullScale, HorizontalScale, VerticalScale};
    OThemeCache( int maxSize, QObject *parent = 0, const char *name = 0 );
    bool insert( OThemePixmap *pixmap, ScaleHint scale, int widgetID,
                 bool border = false, bool mask = false );
    OThemePixmap* pixmap( int w, int h, int widgetID, bool border = false,
                          bool mask = false );
    OThemePixmap* horizontalPixmap( int w, int widgetID );
    OThemePixmap* verticalPixmap( int h, int widgetID );
protected slots:
    void flushTimeout();
protected:
    QIntCache<OThemePixmap> cache;
    QTimer flushTimer;

private:
    class OThemeCachePrivate;
    OThemeCachePrivate *d;
};


class OThemeBase: public QWindowsStyle
{
    Q_OBJECT
public:
    OThemeBase( const QString &configFile );
    ~OThemeBase();
    enum ScaleHint{FullScale, HorizontalScale, VerticalScale, TileScale};
    enum ArrowStyle{MotifArrow, LargeArrow, SmallArrow};
    enum ShadeStyle{Motif, Windows, Next, KDE};
    enum SButton{SBBottomLeft, SBBottomRight, SBOpposite};
    enum Gradient{GrNone, GrHorizontal, GrVertical, GrDiagonal, GrPyramid,
                  GrRectangle, GrElliptic, GrReverseBevel};
    /* Internal note: The order here is important. Some widgets inherit
     * properties. This is usually for when you have two settings for the
     * same widget, ie: on(sunken), and off. The on settings will inherit
     * the properties of the off one when nothing is specified in the config.
     *
     * In order to be able to handle this while still having everything in
     * one group that is easy to loop from we have the following order:
     * unsunked(off) items, sunken(on)items, and then the ones that don't
     * matter. INHERIT_ITEMS define the number of widgets that have inheritence
     * so if 0 == PushButtonOff then INHERIT_ITEMS should == PushButtonOn
     * and so on. WIDGETS define the total number of widgets.
     */
    enum WidgetType{
        // Off (unsunken widgets)
        PushButton = 0, ComboBox, HScrollBarSlider, VScrollBarSlider, Bevel,
        ToolButton, ScrollButton, HScrollDeco, VScrollDeco,
        ComboDeco, MenuItem, InactiveTab, ArrowUp, ArrowDown, ArrowLeft,
        ArrowRight,
        // On (sunken widgets)
        PushButtonDown, ComboBoxDown, HScrollBarSliderDown,
        VScrollBarSliderDown, BevelDown, ToolButtonDown, ScrollButtonDown,
        HScrollDecoDown, VScrollDecoDown, ComboDecoDown, MenuItemDown,
        ActiveTab, SunkenArrowUp, SunkenArrowDown, SunkenArrowLeft,
        SunkenArrowRight,
        // Everything else (indicators must have separate settings)
        HScrollGroove, VScrollGroove, Slider, SliderGroove, IndicatorOn,
        IndicatorOff, ExIndicatorOn, ExIndicatorOff, HBarHandle, VBarHandle,
        ToolBar, Splitter, CheckMark, MenuBar, DisArrowUp, DisArrowDown,
        DisArrowLeft, DisArrowRight, ProgressBar, ProgressBg, MenuBarItem,
        Background};

    ScaleHint scaleHint( WidgetType widget ) const;
    Gradient gradientHint( WidgetType widget ) const;
    const QColorGroup* colorGroup( const QColorGroup &defaultGroup,
                                   WidgetType widget ) const;

    QBrush pixmapBrush( const QColorGroup &group, QColorGroup::ColorRole role,
                        int w, int h, WidgetType widget );
    bool isPixmap( WidgetType widget ) const;
    bool isColor( WidgetType widget ) const;
    bool is3DFocus() const;
    int focusOffset() const;
    int borderWidth( WidgetType widget ) const;
    int pixBorderWidth( WidgetType widget ) const;
    OThemePixmap* borderPixmap( WidgetType widget );
    int highlightWidth( WidgetType widget ) const;
    int decoWidth( WidgetType widget ) const;
    int getSBExtent() const;
    SButton scrollBarLayout() const;
    ArrowStyle arrowType() const;
    ShadeStyle shade() const;
    int frameWidth() const;
    int splitWidth() const;
    int bevelContrast( WidgetType widget ) const;
    int buttonXShift() const;
    int buttonYShift() const;
    int sliderButtonLength() const;
    bool roundButton() const;
    bool roundComboBox() const;
    bool roundSlider() const;
    bool activeTabLine() const;
    bool inactiveTabLine() const;
    OThemePixmap* uncached( WidgetType widget ) const;
    virtual OThemePixmap *scalePixmap( int w, int h, WidgetType widget );
    static void applyConfigFile( const QString &file );
protected:
    QImage* image( WidgetType widget ) const;
    QColor* gradientHigh( WidgetType widget ) const;
    QColor* gradientLow( WidgetType widget ) const;
    void readConfig( Qt::GUIStyle colorStyle = Qt::WindowsStyle );
    void readWidgetConfig( int i, Config *config, QString *pixnames,
                           QString *brdnames, bool *loadArray );
    void copyWidgetConfig( int sourceID, int destID, QString *pixnames,
                           QString *brdnames );
    QColorGroup* makeColorGroup( QColor &fg, QColor &bg,
                                 Qt::GUIStyle style = Qt::WindowsStyle );
    OThemePixmap* scale( int w, int h, WidgetType widget );
    OThemePixmap* scaleBorder( int w, int h, WidgetType type );
    OThemePixmap* gradient( int w, int h, WidgetType widget );
    OThemePixmap* blend( WidgetType widget );
    void generateBorderPix( int i );
    void applyResourceGroup( Config *config, int i, QString *copyfrom, QString *pixnames, QString *brdnames );
    void applyMiscResourceGroup( Config *config );
    void readResourceGroup( int i, QString *copyfrom, QString *pixnames, QString *brdnames,
                            bool *loadArray );
    void readMiscResourceGroup();
    OThemePixmap* loadPixmap( QString &name );
    QImage* loadImage( QString &name );
private:
    SButton sbPlacement;
    ArrowStyle arrowStyle;
    ShadeStyle shading;
    int defaultFrame;
    int btnXShift, btnYShift;
    int sliderLen;
    int splitterWidth;
    int focus3DOffset;
    int sbExtent;
    bool smallGroove;
    bool roundedButton, roundedCombo, roundedSlider;
    bool aTabLine, iTabLine;
    bool focus3D;
    OThemeCache *cache;
    int cacheSize;
    QString configFileName;
    QString configFilePath;

protected:
    QColor fgcolor, bgcolor, selfgcolor, selbgcolor, winfgcolor, winbgcolor;

private:
    OThemePixmap *pixmaps[ WIDGETS ];
    QImage *images[ WIDGETS ];
    unsigned char borders[ WIDGETS ];
    unsigned char highlights[ WIDGETS ];
    ScaleHint scaleHints[ WIDGETS ];
    QColorGroup *colors[ WIDGETS ];
    QColor *grLowColors[ WIDGETS ];
    QColor *grHighColors[ WIDGETS ];
    Gradient gradients[ WIDGETS ];
    float blends[ WIDGETS ];
    unsigned char bContrasts[ WIDGETS ];
    bool duplicate[ WIDGETS ];
    int pbWidth[ WIDGETS ];
    OThemePixmap *pbPixmaps[ WIDGETS ];
    bool pbDuplicate[ WIDGETS ];

private:
    class OThemeBasePrivate;
    OThemeBasePrivate *d;

};

inline bool OThemeBase::isPixmap( WidgetType widget ) const
{
    return ( pixmaps[ widget ] != NULL || gradients[ widget ] != GrNone );
}

inline bool OThemeBase::isColor( WidgetType widget ) const
{
    return ( colors[ widget ] != NULL );
}

inline bool OThemeBase::is3DFocus() const
{
    return ( focus3D );
}

inline int OThemeBase::focusOffset() const
{
    return ( focus3DOffset );
}

inline int OThemeBase::bevelContrast( WidgetType widget ) const
{
    return ( bContrasts[ widget ] );
}

inline OThemeBase::ScaleHint OThemeBase::scaleHint( WidgetType widget ) const
{
    return ( ( widget < WIDGETS ) ? scaleHints[ widget ] : TileScale );
}

inline OThemeBase::Gradient OThemeBase::gradientHint( WidgetType widget ) const
{
    return ( ( widget < WIDGETS ) ? gradients[ widget ] : GrNone );
}

inline OThemePixmap* OThemeBase::uncached( WidgetType widget ) const
{
    return ( pixmaps[ widget ] );
}

inline QBrush OThemeBase::pixmapBrush( const QColorGroup &group,
                                       QColorGroup::ColorRole role,
                                       int w, int h, WidgetType widget )
{
    if ( pixmaps[ widget ] || images[ widget ] )
        return ( QBrush( group.color( role ), *scalePixmap( w, h, widget ) ) );
    else
        return ( group.color( role ) );
}

inline const QColorGroup* OThemeBase::colorGroup( const QColorGroup &defaultGroup,
        WidgetType widget ) const
{
    return ( ( colors[ widget ] ) ? colors[ widget ] : &defaultGroup );
}

inline int OThemeBase::borderWidth( WidgetType widget ) const
{
    return ( pbWidth[ widget ] ? pbWidth[ widget ] : borders[ widget ] );
}

inline int OThemeBase::pixBorderWidth( WidgetType widget ) const
{
    return ( pbWidth[ widget ] );
}

inline int OThemeBase::highlightWidth( WidgetType widget ) const
{
    return ( pbWidth[ widget ] ? 0 : highlights[ widget ] );
}

inline int OThemeBase::decoWidth( WidgetType widget ) const
{
    return ( pbWidth[ widget ] ? pbWidth[ widget ] : borders[ widget ] + highlights[ widget ] );
}

inline QColor* OThemeBase::gradientHigh( WidgetType widget ) const
{
    return ( grHighColors[ widget ] );
}

inline QColor* OThemeBase::gradientLow( WidgetType widget ) const
{
    return ( grLowColors[ widget ] );
}

inline QImage* OThemeBase::image( WidgetType widget ) const
{
    return ( images[ widget ] );
}

inline OThemeBase::SButton OThemeBase::scrollBarLayout() const
{
    return ( sbPlacement );
}

inline OThemeBase::ArrowStyle OThemeBase::arrowType() const
{
    return ( arrowStyle );
}

inline OThemeBase::ShadeStyle OThemeBase::shade() const
{
    return ( shading );
}

inline int OThemeBase::frameWidth() const
{
    return ( defaultFrame );
}

inline int OThemeBase::buttonXShift() const
{
    return ( btnXShift );
}

inline int OThemeBase::splitWidth() const
{
    return ( splitterWidth );
}

inline int OThemeBase::buttonYShift() const
{
    return ( btnYShift );
}

inline int OThemeBase::sliderButtonLength() const
{
    if ( isPixmap( Slider ) )
        return ( uncached( Slider ) ->width() );
    else
        return ( sliderLen );
}

inline bool OThemeBase::roundButton() const
{
    return ( roundedButton );
}

inline bool OThemeBase::roundComboBox() const
{
    return ( roundedCombo );
}

inline bool OThemeBase::roundSlider() const
{
    return ( roundedSlider );
}

inline bool OThemeBase::activeTabLine() const
{
    return ( aTabLine );
}

inline bool OThemeBase::inactiveTabLine() const
{
    return ( iTabLine );
}

inline int OThemeBase::getSBExtent() const
{
    return ( sbExtent );
}

inline OThemePixmap* OThemeBase::borderPixmap( WidgetType widget )
{
    return ( pbPixmaps[ widget ] );
}

#endif

---