kexigradientwidget.h

/* This file is part of the KDE project
   Copyright (C) 2005 Christian Nitschkowski <segfault_ii@web.de>
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library 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
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this program; see the file COPYING.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
*/
 
#ifndef KEXIGRADIENTWIDGET_H
#define KEXIGRADIENTWIDGET_H
 
#include <tqtimer.h>
#include <tqwidget.h>
 
#include <kimageeffect.h>
#include <kpixmap.h>
 
#define REBUILD_DELAY 100
 
 
class KEXIGUIUTILS_EXPORT KexiGradientWidget : public TQWidget {
    typedef TQPtrList<TQWidget> WidgetList;
 
    TQ_OBJECT
  
    TQ_PROPERTY(DisplayMode displayMode READ displayMode WRITE setDisplayMode DESIGNABLE true)
    TQ_PROPERTY(GradientType gradientType READ gradientType WRITE setGradientType DESIGNABLE true)
    TQ_PROPERTY(TQColor gradientColor1 READ gradientColor1 WRITE setGradientColor1 DESIGNABLE true)
    TQ_PROPERTY(TQColor gradientColor2 READ gradientColor2 WRITE setGradientColor2 DESIGNABLE true)
    TQ_PROPERTY(double blendOpacity READ blendOpacity WRITE setBlendOpacity DESIGNABLE true)
    TQ_ENUMS( DisplayMode GradientType )
 
    public:
        enum DisplayMode {
            NoGradient, 
            FadedGradient, 
            SimpleGradient 
        };
 
        enum GradientType {
            VerticalGradient = KImageEffect::VerticalGradient,
            HorizontalGradient = KImageEffect::HorizontalGradient,
            DiagonalGradient = KImageEffect::DiagonalGradient,
            CrossDiagonalGradient = KImageEffect::CrossDiagonalGradient,
            PyramidGradient = KImageEffect::PyramidGradient,
            RectangleGradient = KImageEffect::RectangleGradient,
            PipeCrossGradient = KImageEffect::PipeCrossGradient,
            EllipticGradient = KImageEffect::EllipticGradient
        };
 
        KexiGradientWidget( TQWidget *parent = 0, const char *name = 0, WFlags f = 0 );
 
        virtual ~KexiGradientWidget();
 
        virtual void setPaletteBackgroundPixmap( const TQPixmap& pixmap ) {
            p_backgroundPixmap = pixmap;
            p_rebuildDelayTimer.start( REBUILD_DELAY, true );
        }
 
        virtual const TQColor& paletteBackgroundColor() const;
 
        void setDisplayMode( DisplayMode mode ) {
            p_displayMode = mode;
            p_cacheDirty = true;
            update();
        }
 
        DisplayMode displayMode() const {
            return p_displayMode;
        }
 
        void setGradientType( GradientType type ) {
            p_gradientType = type;
            p_cacheDirty = true;
            update();
        }
 
        GradientType gradientType() const {
            return p_gradientType;
        }
 
        void setGradientColor1( const TQColor& color ) {
            p_color1 = color;
            p_cacheDirty = true;
        }
 
        void setGradientColor2( const TQColor& color ) {
            p_color2 = color;
            p_cacheDirty = true;
        }
 
        void setGradientColors( const TQColor& color1, const TQColor& color2 ) {
            p_color1 = color1;
            p_color2 = color2;
            p_cacheDirty = true;
            }
 
        TQColor gradientColor1() const { return p_color1; }
 
        TQColor gradientColor2() const { return p_color2; }
 
        void setBlendOpacity( double opacity ) {
            p_opacity = opacity;
            p_cacheDirty = true;
        }
 
        double blendOpacity() const { return p_opacity; }
 
    public slots:
        virtual void setPaletteBackgroundColor( const TQColor& color );
 
    protected:
        virtual bool eventFilter( TQObject* object, TQEvent* event );
        virtual void enabledChange( bool enabled ) {
            p_cacheDirty = true;
            TQWidget::enabledChange( enabled );
        }
 
        virtual void paletteChange( const TQPalette& pal ) {
            p_cacheDirty = true;
            TQWidget::paletteChange( pal );
        }
 
        virtual void paintEvent( TQPaintEvent* e );
 
        virtual void resizeEvent( TQResizeEvent* e ) {
            p_rebuildDelayTimer.start( REBUILD_DELAY, true );
            TQWidget::resizeEvent( e );
        }
 
        virtual void styleChange( TQStyle& style ) {
            p_cacheDirty = true;
            TQWidget::styleChange( style );
        }
 
    private:
        static void buildChildrenList( WidgetList& list, TQWidget* p );
        static bool isValidChildWidget( TQObject* child );
 
        void rebuildCache();
 
        void updateChildBackground( TQWidget* childWidget );
 
    private:
        WidgetList p_knownWidgets;
        WidgetList p_customBackgroundWidgets;
        DisplayMode p_displayMode;
        GradientType p_gradientType;
        KPixmap p_backgroundPixmap;
        TQColor p_color1;
        TQColor p_color2;
        TQTimer p_rebuildDelayTimer;
        TQWidget* p_currentChild;
        double p_opacity;
        bool p_cacheDirty;
 
        TQColor p_backgroundColor;
 
    public slots:
        virtual void polish() {
            TQWidget::polish();
            rebuildCache();
        }
 
    private slots:
        void setCacheDirty() {
            rebuildCache();
        }
 
    };
 
#endif