Source Code (Use browser search to find items of interest.)

kpresenter'KPGradient (./koffice/kpresenter/kpgradient.h:44)

class KPGradient
{
public:
    KPGradient( QColor _color1, QColor _color2, BCType _bcType, QSize _size,
		bool _unbalanced, int _xfactor, int _yfactor );
    virtual ~KPGradient()
    {}

    virtual QColor getColor1()
    { return color1; }
    virtual QColor getColor2()
    { return color2; }
    virtual BCType getBackColorType()
    { return bcType; }
    virtual bool getUnbalanced()
    { return unbalanced; }
    virtual int getXFactor()
    { return xFactor; }
    virtual int getYFactor()
    { return yFactor; }

    virtual void setColor1( QColor _color )
    { color1 = _color; paint(); }
    virtual void setColor2( QColor _color )
    { color2 = _color; paint(); }
    virtual void setBackColorType( BCType _type )
    { bcType = _type; paint(); }
    virtual void setUnbalanced( bool b )
    { unbalanced = b; paint(); }
    virtual void setXFactor( int i )
    { xFactor = i; paint(); }
    virtual void setYFactor( int i )
    { yFactor = i; paint(); }

    virtual QPixmap* getGradient()
    { return (QPixmap*)&pixmap; }
    virtual QSize getSize()
    { return pixmap.size(); }

    virtual void setSize( QSize _size ) {
	if ( _size != pixmap.size() ) {
	    pixmap.resize( _size );
	    paint();
	}
    }

    virtual void addRef();
    virtual bool removeRef();

protected:
    KPGradient()
    {; }
    virtual void paint();

    QColor color1, color2;
    BCType bcType;

    KPixmap pixmap;
    int refCount;

    bool unbalanced;
    int xFactor, yFactor;

};

kpresenter'KPGradient::KPGradient() (./koffice/kpresenter/kpgradient.cc:31)

KPGradient::KPGradient( QColor _color1, QColor _color2, BCType _bcType, QSize _size,
			bool _unbalanced, int _xfactor, int _yfactor )
    : color1( _color1 ), color2( _color2 ), pixmap(), refCount( 0 ), unbalanced( _unbalanced ),
      xFactor( _xfactor ), yFactor( _yfactor )
{
    bcType = _bcType;
    pixmap.resize( _size );
    paint();
}

/*====================== add reference ==========================*/

kpresenter'KPGradient::addRef() (./koffice/kpresenter/kpgradient.cc:42)

void KPGradient::addRef()
{
    ++refCount;
}

/*====================== remove reference =======================*/

kpresenter'KPGradient::removeRef() (./koffice/kpresenter/kpgradient.cc:48)

bool KPGradient::removeRef()
{
    return ( --refCount == 0 );
}

/*====================== paint ===================================*/

kpresenter'KPGradient::paint() (./koffice/kpresenter/kpgradient.cc:54)

void KPGradient::paint()
{
    QPainter painter;

    switch ( bcType ) {
    case BCT_PLAIN:
	painter.begin( &pixmap );

	painter.setPen( Qt::NoPen );
	painter.setBrush( color1 );
	painter.drawRect( QRect( 0, 0, pixmap.size().width(), pixmap.size().height() ) );

	painter.end();
	break;
    case BCT_GHORZ: {
	if ( !unbalanced )
	    KPixmapEffect::gradient( pixmap, color1, color2, KPixmapEffect::VerticalGradient );
	else
	    KPixmapEffect::unbalancedGradient( pixmap, color1, color2, KPixmapEffect::VerticalGradient,
					       xFactor, yFactor );
    } break;
    case BCT_GVERT: {
	if ( !unbalanced )
	    KPixmapEffect::gradient( pixmap, color1, color2, KPixmapEffect::HorizontalGradient );
	else
	    KPixmapEffect::unbalancedGradient( pixmap, color1, color2, KPixmapEffect::HorizontalGradient,
					       xFactor, yFactor );
    } break;
    case BCT_GDIAGONAL1: {
	if ( !unbalanced )
	    KPixmapEffect::gradient( pixmap, color1, color2, KPixmapEffect::DiagonalGradient );
	else
	    KPixmapEffect::unbalancedGradient( pixmap, color1, color2, KPixmapEffect::DiagonalGradient,
					       xFactor, yFactor );
    } break;
    case BCT_GDIAGONAL2: {
	if ( !unbalanced )
	    KPixmapEffect::gradient( pixmap, color1, color2, KPixmapEffect::CrossDiagonalGradient );
	else
	    KPixmapEffect::unbalancedGradient( pixmap, color1, color2,
					       KPixmapEffect::CrossDiagonalGradient,  xFactor, yFactor );
    } break;
    case BCT_GCIRCLE: {
	if ( !unbalanced )
	    KPixmapEffect::gradient( pixmap, color1, color2, KPixmapEffect::EllipticGradient );
	else
	    KPixmapEffect::unbalancedGradient( pixmap, color1, color2,
					       KPixmapEffect::EllipticGradient, xFactor, yFactor );
    } break;
    case BCT_GRECT: {
	if ( !unbalanced )
	    KPixmapEffect::gradient( pixmap, color1, color2, KPixmapEffect::RectangleGradient );
	else
	    KPixmapEffect::unbalancedGradient( pixmap, color1, color2,
					       KPixmapEffect::RectangleGradient, xFactor, yFactor );
    } break;
    case BCT_GPIPECROSS: {
	if ( !unbalanced )
	    KPixmapEffect::gradient( pixmap, color1, color2, KPixmapEffect::PipeCrossGradient );
	else
	    KPixmapEffect::unbalancedGradient( pixmap, color1, color2,
					       KPixmapEffect::PipeCrossGradient, xFactor, yFactor );
    } break;
    case BCT_GPYRAMID: {
	if ( !unbalanced )
	    KPixmapEffect::gradient( pixmap, color1, color2, KPixmapEffect::PyramidGradient );
	else
	    KPixmapEffect::unbalancedGradient( pixmap, color1, color2,
					       KPixmapEffect::PyramidGradient, xFactor, yFactor );
    } break;
    }
}