kexidblabel.cpp

/* This file is part of the KDE project
   Copyright (C) 2005 Christian Nitschkowski <segfault_ii@web.de>
   Copyright (C) 2005 Jaroslaw Staniek <js@iidea.pl>
 
   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 "kexidblabel.h"
 
#include <tqbitmap.h>
#include <tqpainter.h>
#include <tqdrawutil.h>
#include <tqapplication.h>
#include <tqtimer.h>
 
#include <kdebug.h>
#include <kimageeffect.h>
 
#include <kexidb/field.h>
#include <kexiutils/utils.h>
 
#define SHADOW_OFFSET_X 3
#define SHADOW_OFFSET_Y 3
#define SHADOW_FACTOR 16.0
#define SHADOW_OPACITY 50.0
#define SHADOW_AXIS_FACTOR 2.0
#define SHADOW_DIAGONAL_FACTOR 1.0
#define SHADOW_THICKNESS 1
 
class KexiDBInternalLabel : public TQLabel {
        friend class KexiDBLabel;
    public:
        KexiDBInternalLabel( KexiDBLabel* );
        virtual ~KexiDBInternalLabel();
 
    protected:
        void updateFrame();
 
        TQImage makeShadow( const TQImage& textImage, const TQColor &bgColor, const TQRect& boundingRect );
        TQRect getBounding( const TQImage &image, const TQRect& startRect );
//      double defaultDecay( TQImage& source, int i, int j );
        KPixmap getShadowPixmap();
 
        TQRect m_shadowRect;
        KexiDBLabel *m_parentLabel;
};
 
KexiDBInternalLabel::KexiDBInternalLabel( KexiDBLabel* parent )
    : TQLabel( parent )
    , m_parentLabel(parent)
{
    int a = alignment() | TQt::WordBreak;
    a &= (0xffffff ^ TQt::AlignVertical_Mask);
    a |= TQt::AlignTop;
    setAlignment( a );
    updateFrame();
}
 
void KexiDBInternalLabel::updateFrame()
{
    setIndent(m_parentLabel->indent());
    setMargin(m_parentLabel->margin());
    setFont(m_parentLabel->font());
 
    setFrameShadow(m_parentLabel->frameShadow());
    setFrameShape(m_parentLabel->frameShape());
    setFrameStyle(m_parentLabel->frameStyle());
    setMidLineWidth(m_parentLabel->midLineWidth());
    setLineWidth(m_parentLabel->lineWidth());
}
 
KexiDBInternalLabel::~KexiDBInternalLabel()
{
}
 
TQImage KexiDBInternalLabel::makeShadow( const TQImage& textImage, 
    const TQColor &bgColor, const TQRect& boundingRect )
{
    TQImage result;
    TQString origText( text() );
 
    // create a new image for for the shaddow
    const int w = textImage.width();
    const int h = textImage.height();
 
    // avoid calling these methods for every pixel
    const int bgRed = bgColor.red();
    const int bgGreen = bgColor.green();
    const int bgBlue = bgColor.blue();
 
    const int startX = boundingRect.x() + SHADOW_THICKNESS;
    const int startY = boundingRect.y() + SHADOW_THICKNESS;
    const int effectWidth = boundingRect.bottomRight().x() - SHADOW_THICKNESS;
    const int effectHeight = boundingRect.bottomRight().y() - SHADOW_THICKNESS;
//  const int period = (effectWidth - startX) / 10;
 
    double alphaShadow;
 
    /*
     *  This is the source pixmap
     */
    TQImage img = textImage.convertDepth( 32 );
 
    /*
     *  Resize the image if necessary
     */
    if ( ( result.width() != w ) || ( result.height() != h ) ) {
        result.create( w, h, 32 );
    }
 
//  result.fill( 0 ); // all black
    double realOpacity = SHADOW_OPACITY + TQMIN(50.0/double(256.0-tqGray(bgColor.rgb())), 50.0);
    //int _h, _s, _v;
    //.getHsv( &_h, &_s, &_v );
    if (colorGroup().background()==TQt::red)//_s>=250 && _v>=250) //for colors like cyan or red, make the result more white
        realOpacity += 50.0;
    result.fill( (int)realOpacity );
    result.setAlphaBuffer( true );
 
    for ( int i = startX; i < effectWidth; i++ ) {
        for ( int j = startY; j < effectHeight; j++ ) {
                if ( ( i < 1 ) || ( j < 1 ) || ( i > img.width() - 2 ) || ( j > img.height() - 2 ) )
                    continue;
                else
                    alphaShadow = ( tqGray( img.pixel( i - 1, j - 1 ) ) * SHADOW_DIAGONAL_FACTOR +
                        tqGray( img.pixel( i - 1, j ) ) * SHADOW_AXIS_FACTOR +
                        tqGray( img.pixel( i - 1, j + 1 ) ) * SHADOW_DIAGONAL_FACTOR +
                        tqGray( img.pixel( i , j - 1 ) ) * SHADOW_AXIS_FACTOR +
                        0 +
                        tqGray( img.pixel( i , j + 1 ) ) * SHADOW_AXIS_FACTOR +
                        tqGray( img.pixel( i + 1, j - 1 ) ) * SHADOW_DIAGONAL_FACTOR +
                        tqGray( img.pixel( i + 1, j ) ) * SHADOW_AXIS_FACTOR +
                        tqGray( img.pixel( i + 1, j + 1 ) ) * SHADOW_DIAGONAL_FACTOR ) / SHADOW_FACTOR;
 
            // update the shadow's i,j pixel.
            if (alphaShadow > 0)
                result.setPixel( i, j, tqRgba( bgRed, bgGreen , bgBlue, 
                    ( int ) (( alphaShadow > realOpacity ) ? realOpacity : alphaShadow)
                ) );
        }
/*caused too much redraw problems       if (period && i % period) {
            tqApp->processEvents();
            if (text() != origText) //text has been changed in the meantime: abort
                return TQImage();
        }*/
    }
    return result;
}
 
KPixmap KexiDBInternalLabel::getShadowPixmap() {
    const TQColor textColor = colorGroup().foreground();
 
    KPixmap finalPixmap, tempPixmap;
    TQImage shadowImage, tempImage;
    TQPainter painter;
 
    m_shadowRect = TQRect();
 
    tempPixmap.resize( size() );
    tempPixmap.fill( TQt::black );
    tempPixmap.setMask( tempPixmap.createHeuristicMask( true ) );
 
    setPaletteForegroundColor( TQt::white );
 
    painter.begin( &tempPixmap );
    painter.setFont( font() );
    drawContents( &painter );
    painter.end();
    setPaletteForegroundColor( textColor );
 
    shadowImage = tempPixmap;
    tempPixmap.setMask( TQBitmap() );
 
    m_shadowRect = getBounding( shadowImage, m_shadowRect );
 
    m_shadowRect.setX( TQMAX( m_shadowRect.x() - ( m_shadowRect.width() / 4 ), 0 ) );
    m_shadowRect.setY( TQMAX( m_shadowRect.y() - ( m_shadowRect.height() / 4 ), 0 ) );
    m_shadowRect.setBottomRight( TQPoint(
        TQMIN( m_shadowRect.x() + ( m_shadowRect.width() * 3 / 2 ), shadowImage.width() ),
        TQMIN( m_shadowRect.y() + ( m_shadowRect.height() * 3 / 2 ), shadowImage.height() ) ) );
 
    shadowImage = makeShadow( shadowImage,
        tqGray( colorGroup().background().rgb() ) < 127 ? TQt::white : TQt::black,
        m_shadowRect );
    if (shadowImage.isNull())
        return KPixmap();
 
    m_shadowRect = getBounding( shadowImage, m_shadowRect );
 
    finalPixmap.resize( size() );
    painter.begin( &finalPixmap );
    painter.fillRect( 0, 0, finalPixmap.width(), finalPixmap.height(),
        palette().brush(
        isEnabled() ? TQPalette::Active : TQPalette::Disabled,
        TQColorGroup::Background ) );
    painter.end();
 
    tempPixmap.resize( m_shadowRect.size() );
    if (!finalPixmap.isNull()) {
        bitBlt( &tempPixmap, 0, 0, &finalPixmap,
            m_shadowRect.x() + SHADOW_OFFSET_X,
            m_shadowRect.y() + SHADOW_OFFSET_Y,
            m_shadowRect.width(),
            m_shadowRect.height() );
    }
    finalPixmap = tempPixmap;
 
    tempImage = shadowImage.copy( m_shadowRect );
    tempPixmap.convertFromImage( tempImage );
    if (!tempPixmap.isNull()) {
        bitBlt( &finalPixmap, 0, 0, &tempPixmap );
    }
 
    m_shadowRect.moveBy( SHADOW_OFFSET_X, SHADOW_OFFSET_Y );
 
    return finalPixmap;
}
 
TQRect KexiDBInternalLabel::getBounding( const TQImage &image, const TQRect& startRect ) {
    TQPoint topLeft;
    TQPoint bottomRight;
 
    const int startX = startRect.x();
    const int startY = startRect.y();
    const int width = TQMIN( ( startRect.bottomRight().x() > 0
        ? startRect.bottomRight().x() : TQCOORD_MAX ),
        image.width() );
    const int height = TQMIN( ( startRect.bottomRight().y() > 0
        ? startRect.bottomRight().y() : TQCOORD_MAX ),
        image.height() );
 
    TQRgb trans = image.pixel( 0, 0 );
 
    for ( int y = startY; y < height; y++ ) {
        for ( int x = startX; x < width; x++ ) {
            if ( image.pixel( x, y ) != trans ) {
                topLeft.setY( y );
                y = height;
                break;
            }
        }
    }
 
    for ( int x = startX; x < width; x++ ) {
        for ( int y = startY; y < height; y++ ) {
            if ( image.pixel( x, y ) != trans ) {
                topLeft.setX( x );
                x = width;
                break;
            }
        }
    }
 
    for ( int y = height - 1; y > topLeft.y(); y-- ) {
        for ( int x = width - 1; x > topLeft.x(); x-- ) {
            if ( image.pixel( x, y ) != trans ) {
                bottomRight.setY( y + 1 );
                y = 0;
                break;
            }
        }
    }
 
    for ( int x = width - 1; x > topLeft.x(); x-- ) {
        for ( int y = height - 1; y > topLeft.y(); y-- ) {
            if ( image.pixel( x, y ) != trans ) {
                bottomRight.setX( x + 1 );
                x = 0;
                break;
            }
        }
    }
 
    return TQRect(
        topLeft.x(),
        topLeft.y(),
        bottomRight.x() - topLeft.x(),
        bottomRight.y() - topLeft.y() );
}
 
//=========================================================
 
class KexiDBLabel::Private
{
    public:
        Private()
        : timer(0)
//      , autonumberDisplayParameters(0)
        , pixmapDirty( true )
        , shadowEnabled( false )
        , resizeEvent( false )
        {
        }
        ~Private() {}
        KPixmap shadowPixmap;
        TQPoint shadowPosition;
        KexiDBInternalLabel* internalLabel;
        TQTimer* timer;
        TQColor frameColor;
        bool pixmapDirty : 1;
        bool shadowEnabled : 1;
        bool resizeEvent : 1;
};
 
//=========================================================
 
KexiDBLabel::KexiDBLabel( TQWidget *parent, const char *name, WFlags f )
    : TQLabel( parent, name, f )
    , KexiDBTextWidgetInterface()
    , KexiFormDataItemInterface()
    , d( new Private() )
{
    init();
}
 
KexiDBLabel::KexiDBLabel( const TQString& text, TQWidget *parent, const char *name, WFlags f )
    : TQLabel( parent, name, f )
    , KexiDBTextWidgetInterface()
    , KexiFormDataItemInterface()
    , d( new Private() )
{
    init();
    setText( text );
}
 
KexiDBLabel::~KexiDBLabel()
{
    delete d;
}
 
void KexiDBLabel::init()
{
    m_hasFocusableWidget = false;
    d->internalLabel = new KexiDBInternalLabel( this );
    d->internalLabel->hide();
    d->frameColor = palette().active().foreground();
 
    setAlignment( d->internalLabel->alignment() );
}
 
void KexiDBLabel::updatePixmapLater() {
    if (d->resizeEvent) {
        if (!d->timer) {
            d->timer = new TQTimer(this, "KexiDBLabelTimer");
            connect(d->timer, TQ_SIGNAL(timeout()), this, TQ_SLOT(updatePixmap()));
        }
        d->timer->start(100, true);
        d->resizeEvent = false;
        return;
    }
    if (d->timer && d->timer->isActive())
        return;
    updatePixmap();
}
 
void KexiDBLabel::updatePixmap() {
    d->internalLabel->setText( text() );
    d->internalLabel->setFixedSize( size() );
    d->internalLabel->setPalette( palette() );
    d->internalLabel->setAlignment( alignment() );
//  d->shadowPixmap = KPixmap(); //parallel repaints won't hurt us cause incomplete pixmap
    KPixmap shadowPixmap = d->internalLabel->getShadowPixmap();
    if (shadowPixmap.isNull())
        return;
    d->shadowPixmap = shadowPixmap;
    d->shadowPosition = d->internalLabel->m_shadowRect.topLeft();
    d->pixmapDirty = false;
    repaint();
}
 
void KexiDBLabel::paintEvent( TQPaintEvent* e )
{
    TQPainter p( this );
    if ( d->shadowEnabled ) {
        if ( d->pixmapDirty ) {
            updatePixmapLater();
        }
 
        if ( !d->pixmapDirty && e->rect().contains( d->shadowPosition ) && !d->shadowPixmap.isNull()) {
            TQRect clipRect = TQRect(
                TQMAX( e->rect().x() - d->shadowPosition.x(), 0 ),
                TQMAX( e->rect().y() - d->shadowPosition.y(), 0 ),
                TQMIN( e->rect().width() + d->shadowPosition.x(), d->shadowPixmap.width() ),
                TQMIN( e->rect().height() + d->shadowPosition.y(), d->shadowPixmap.height() ) );
            p.drawPixmap( d->internalLabel->m_shadowRect.topLeft(), d->shadowPixmap, clipRect );
        }
    }
    KexiDBTextWidgetInterface::paint( this, &p, text().isEmpty(), alignment(), false );
    TQLabel::paintEvent( e );
}
 
void KexiDBLabel::setValueInternal( const TQVariant& add, bool removeOld ) {
    if (removeOld) 
        setText(add.toString());
    else
        setText( m_origValue.toString() + add.toString() );
}
 
TQVariant KexiDBLabel::value() {
    return text();
}
 
void KexiDBLabel::setInvalidState( const TQString& displayText )
{
    setText( displayText );
}
 
bool KexiDBLabel::valueIsNull()
{
    return text().isNull();
}
 
bool KexiDBLabel::valueIsEmpty()
{
    return text().isEmpty();
}
 
bool KexiDBLabel::isReadOnly() const
{
    return true;
}
 
void KexiDBLabel::setReadOnly( bool readOnly )
{
    Q_UNUSED(readOnly);
}
 
TQWidget* KexiDBLabel::widget()
{
    return this;
}
 
bool KexiDBLabel::cursorAtStart()
{
    return false;
}
 
bool KexiDBLabel::cursorAtEnd()
{
    return false;
}
 
void KexiDBLabel::clear()
{
    setText(TQString());
}
 
bool KexiDBLabel::setProperty( const char * name, const TQVariant & value )
{
    const bool ret = TQLabel::setProperty(name, value);
    if (d->shadowEnabled) {
        if (0==qstrcmp("indent", name) || 0==qstrcmp("font", name) || 0==qstrcmp("margin", name)
            || 0==qstrcmp("frameShadow", name) || 0==qstrcmp("frameShape", name)
            || 0==qstrcmp("frameStyle", name) || 0==qstrcmp("midLineWidth", name)
            || 0==qstrcmp("lineWidth", name)) {
            d->internalLabel->setProperty(name, value);
            updatePixmap();
        }
    }
    return ret;
}
 
void KexiDBLabel::setColumnInfo(KexiDB::QueryColumnInfo* cinfo)
{
    KexiFormDataItemInterface::setColumnInfo(cinfo);
    KexiDBTextWidgetInterface::setColumnInfo(cinfo, this);
}
 
void KexiDBLabel::setShadowEnabled( bool state ) {
    d->shadowEnabled = state;
    d->pixmapDirty = true;
    if (state)
        d->internalLabel->updateFrame();
    repaint();
}
 
void KexiDBLabel::resizeEvent( TQResizeEvent* e ) {
    if (isVisible())
        d->resizeEvent = true;
    d->pixmapDirty = true;
    TQLabel::resizeEvent( e );
}
 
void KexiDBLabel::fontChange( const TQFont& font ) {
    d->pixmapDirty = true;
    d->internalLabel->setFont( font );
    TQLabel::fontChange( font );
}
 
void KexiDBLabel::styleChange( TQStyle& style ) {
    d->pixmapDirty = true;
    TQLabel::styleChange( style );
}
 
void KexiDBLabel::enabledChange( bool enabled ) {
    d->pixmapDirty = true;
    d->internalLabel->setEnabled( enabled );
    TQLabel::enabledChange( enabled );
}
 
void KexiDBLabel::paletteChange( const TQPalette& oldPal ) {
    Q_UNUSED(oldPal);
    d->pixmapDirty = true;
    d->internalLabel->setPalette( palette() );
}
 
/*const TQColor & KexiDBLabel::paletteForegroundColor () const 
{
    return d->foregroundColor;
}
 
void KexiDBLabel::setPaletteForegroundColor ( const TQColor& color )
{
    d->foregroundColor = color;
}*/
 
void KexiDBLabel::frameChanged() {
    d->pixmapDirty = true;
    d->internalLabel->updateFrame();
    TQFrame::frameChanged();
}
 
void KexiDBLabel::showEvent( TQShowEvent* e ) {
    d->pixmapDirty = true;
    TQLabel::showEvent( e );
}
 
void KexiDBLabel::setText( const TQString& text ) {
    d->pixmapDirty = true;
    TQLabel::setText( text );
    //This is necessary for KexiFormDataItemInterface
    valueChanged();
    repaint();
}
 
bool KexiDBLabel::shadowEnabled() const
{
    return d->shadowEnabled;
}
 
#define ClassName KexiDBLabel
#define SuperClassName TQLabel
#include "kexiframeutils_p.cpp"
#include "kexidblabel.moc"