kexigradientwidget.cpp

/* 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.
*/
 
#include <tqapplication.h>
#include <tqbitmap.h>
#include <tqimage.h>
#include <tqobjectlist.h>
#include <tqpainter.h>
#include <tqstyle.h>
 
#include <kimageeffect.h>
#include <kpixmap.h>
 
#include "kexigradientwidget.h"
 
KexiGradientWidget::KexiGradientWidget( TQWidget *parent, const char *name, WFlags f )
    : TQWidget( parent, name, f ), p_displayMode( NoGradient ),
    p_gradientType( VerticalGradient ),
    p_color1( TQt::white ), p_color2( TQt::blue ), p_currentChild( 0 ),
    p_opacity( 0.5 ), p_cacheDirty( true )
{
    p_customBackgroundWidgets.setAutoDelete( false );
    p_knownWidgets.setAutoDelete( false );
 
    p_backgroundColor = TQWidget::paletteBackgroundColor();
 
    connect ( &p_rebuildDelayTimer, TQ_SIGNAL( timeout() ), this, TQ_SLOT( setCacheDirty() ) );
 
    installEventFilter( this );
}
 
KexiGradientWidget::~KexiGradientWidget()
{
}
 
bool KexiGradientWidget::isValidChildWidget( TQObject* child ) {
    const TQWidget* wgt = dynamic_cast<TQWidget*>( child );
 
    if ( wgt == 0L )
        return false;
 
    if ( wgt->inherits( "TQScrollView" ) )
        return false;
    if ( wgt->inherits( "TQComboBox" ) )
        return false;
    if ( wgt->inherits( "TQLineEdit" ) )
        return false;
    if ( wgt->inherits( "KexiDBForm" ) )
        return false;
 
    return true;
}
 
void KexiGradientWidget::buildChildrenList( WidgetList& list, TQWidget* p ) {
    TQObjectList* objects = p->queryList( "TQWidget", 0, false, false );
 
    for ( TQObjectList::Iterator it = objects->begin(); it != objects->end(); ++it ) {
        if ( isValidChildWidget( ( *it ) ) == false )
            continue;
        list.append( dynamic_cast<TQWidget*>( ( *it ) ) );
        buildChildrenList( list, dynamic_cast<TQWidget*>( ( *it ) ) );
    }
 
    delete objects;
}
 
void KexiGradientWidget::rebuildCache( void ) {
    WidgetList childWidgetList;
    buildChildrenList( childWidgetList, this );
 
    if ( p_displayMode == NoGradient ) {
//      if ( p_backgroundPixmap.isNull() ) {
            //unsetPalette();
        //} else {
            TQWidget::setPaletteBackgroundPixmap( p_backgroundPixmap );
        //}
        TQWidget::setPaletteBackgroundColor( p_backgroundColor );
 
        for ( WidgetList::Iterator it = childWidgetList.begin();
            it != childWidgetList.end(); ++it ) {
 
            if ( p_customBackgroundWidgets.contains( ( *it ) ) == false ) {
                ( *it )->unsetPalette();
            }
        }
        p_cacheDirty = false;
        return;
    }
 
    KPixmap tempPixmap;
    TQImage gradientImage;
    TQImage bgImage;
 
    gradientImage = KImageEffect::gradient( size(), p_color1, p_color2,
        (KImageEffect::GradientType)p_gradientType );
 
    if ( p_displayMode == FadedGradient ) {
        tempPixmap.resize( size() );
        TQPainter p( &tempPixmap, this );
 
        if ( p_backgroundPixmap.isNull() ) {
            /*
            Need to unset the palette, otherwise the old gradient
            will be used as a background, not the widget's default bg.
            */
            unsetPalette();
            p.fillRect( 0, 0, width(), height(), palette().brush(
                isEnabled() ? TQPalette::Active : TQPalette::Disabled,
                TQColorGroup::Background ) );
        } else {
            p.drawTiledPixmap( 0, 0, width(), height(), p_backgroundPixmap );
        }
 
        p.end();
 
        bgImage = tempPixmap;
 
        KImageEffect::blend( gradientImage, bgImage, (float)p_opacity );
 
        tempPixmap.convertFromImage( bgImage );
    } else if ( p_displayMode == SimpleGradient ) {
        tempPixmap.convertFromImage( gradientImage );
    }
 
    KPixmap partPixmap;
    TQRect area;
    TQWidget* childWidget = 0;
    const TQPoint topLeft( 0, 0 );
 
    for ( WidgetList::Iterator it = childWidgetList.begin();
        it != childWidgetList.end(); ++it ) {
 
        childWidget = ( *it );
 
        if ( p_customBackgroundWidgets.contains( childWidget ) ) {
            continue;
        }
 
        partPixmap.resize( childWidget->size() );
        if ( childWidget->parent() == this ) {
            area = childWidget->geometry();
        } else {
            area.setTopLeft( childWidget->mapTo( this,
                childWidget->clipRegion().boundingRect().topLeft() ) );
            area.setSize( childWidget->size() );
        }
        bitBlt( &partPixmap, topLeft, &tempPixmap, area );
 
        p_currentChild = childWidget;
        childWidget->setPaletteBackgroundPixmap( partPixmap );
    }
 
    TQWidget::setPaletteBackgroundPixmap( tempPixmap );
    p_cacheDirty = false;
}
 
void KexiGradientWidget::paintEvent( TQPaintEvent* e ) {
    if ( p_cacheDirty == true ) {
        rebuildCache();
    }
 
    TQWidget::paintEvent( e );
}
 
bool KexiGradientWidget::eventFilter( TQObject* object, TQEvent* event ) {
    TQWidget* child = dynamic_cast<TQWidget*>( object );
 
    if ( object == this ) {
        if ( event->type() == TQEvent::ChildInserted ) {
            child = dynamic_cast<TQWidget*>( dynamic_cast<TQChildEvent*>( event )->child() );
            if ( isValidChildWidget( child ) == false ) {
                return false;
            }
            p_knownWidgets.append( child );
            child->installEventFilter( this );
        } else if ( event->type() == TQEvent::ChildRemoved ) {
            p_knownWidgets.remove( dynamic_cast<TQWidget*>( dynamic_cast<TQChildEvent*>( event )->child() ) );
        }
        return false;
    }
 
    if ( event->type() == TQEvent::PaletteChange ) {
        if ( p_currentChild == 0L && child != 0L ) {
            if ( p_customBackgroundWidgets.contains( child ) == false ) {
                p_customBackgroundWidgets.append( child );
                return false;
            }
        }
        if ( child != p_currentChild && child != 0L ) {
            if ( p_customBackgroundWidgets.contains( child ) == false ) {
                if ( child->paletteBackgroundPixmap() != 0L ) {
                    p_customBackgroundWidgets.append( child );
                }
            } else {
                if ( child->paletteBackgroundPixmap() == 0L ) {
                    p_customBackgroundWidgets.remove( child );
                    if ( p_displayMode != NoGradient ) {
                        p_cacheDirty = true;
                    }
                }
            }
        }
        p_currentChild = 0;
    }
 
    if ( event->type() == TQEvent::Move ) {
        if ( p_customBackgroundWidgets.contains( child ) == false ) {
            updateChildBackground( child );
        }
    }
    return false;
}
 
void KexiGradientWidget::updateChildBackground( TQWidget* childWidget )
{
    KPixmap partPixmap;
    KPixmap bgPixmap;
    TQRect area;
    const TQPoint topLeft( 0, 0 );
 
    bgPixmap = paletteBackgroundPixmap() ? (*paletteBackgroundPixmap()) : TQPixmap();
    if ( bgPixmap.isNull() )
        return;
 
    if ( childWidget->parent() == 0L )
        return;
 
    if ( p_customBackgroundWidgets.contains( childWidget ) ) {
        return;
    }
 
    partPixmap.resize( childWidget->size() );
    if ( childWidget->parent() == this ) {
        area = childWidget->geometry();
    } else {
        area.setTopLeft( childWidget->mapTo( this,
            childWidget->clipRegion().boundingRect().topLeft() ) );
        area.setSize( childWidget->size() );
    }
    bitBlt( &partPixmap, topLeft, &bgPixmap, area );
 
    p_currentChild = childWidget;
    childWidget->setPaletteBackgroundPixmap( partPixmap );
}
 
void KexiGradientWidget::setPaletteBackgroundColor( const TQColor& color )
{
    p_backgroundColor = color;
    if ( p_displayMode == NoGradient ) {
        TQWidget::setPaletteBackgroundColor( p_backgroundColor );
    }
}
 
const TQColor& KexiGradientWidget::paletteBackgroundColor() const
{
    return p_backgroundColor;
}
 
#include "kexigradientwidget.moc"